valve-keyvalue 1.0.3

/*
   Copyright 2026 Gerg0Vagyok

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/

use valve_keyvalue::parse::{parse_object, TrackedChars};
use valve_keyvalue::{ValveKeyValue, ValveKeyValueType};
use valve_keyvalue::error::Error;

#[test]
fn parse_object_1() {
	assert_eq!(parse_object(&mut TrackedChars::new("abc {} "), false, 0), Ok(vec![
		ValveKeyValue::new("abc".to_string(), ValveKeyValueType::Object(Vec::new()))
	]))
}

#[test]
fn parse_object_2() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
something
{
	value1 something
	value2 2.5
	idkwhatis "this"
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("something".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("value1".to_string(), ValveKeyValueType::String("something".to_string())),
			ValveKeyValue::new("value2".to_string(), ValveKeyValueType::String("2.5".to_string())),
			ValveKeyValue::new("idkwhatis".to_string(), ValveKeyValueType::String("this".to_string()))
		]))
	]))
}

#[test]
fn parse_object_3() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
something
{
	value1 something
	value2 {
		1 2
		3 4
	}
	idkwhatis "this"
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("something".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("value1".to_string(), ValveKeyValueType::String("something".to_string())),
			ValveKeyValue::new("value2".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("1".to_string(), ValveKeyValueType::String("2".to_string())),
				ValveKeyValue::new("3".to_string(), ValveKeyValueType::String("4".to_string()))
			])),
			ValveKeyValue::new("idkwhatis".to_string(), ValveKeyValueType::String("this".to_string()))
		]))
	]))
}

#[test]
fn parse_object_4() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
something
{
	value1 something
	value2 {
		1 2
		3 4
	}
	idkwhatis "this"
}

something2
{
	value1 something
	value2 {
		1 2
		3 4
	}
	idkwhatis "this"
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("something".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("value1".to_string(), ValveKeyValueType::String("something".to_string())),
			ValveKeyValue::new("value2".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("1".to_string(), ValveKeyValueType::String("2".to_string())),
				ValveKeyValue::new("3".to_string(), ValveKeyValueType::String("4".to_string()))
			])),
			ValveKeyValue::new("idkwhatis".to_string(), ValveKeyValueType::String("this".to_string()))
		])),
		ValveKeyValue::new("something2".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("value1".to_string(), ValveKeyValueType::String("something".to_string())),
			ValveKeyValue::new("value2".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("1".to_string(), ValveKeyValueType::String("2".to_string())),
				ValveKeyValue::new("3".to_string(), ValveKeyValueType::String("4".to_string()))
			])),
			ValveKeyValue::new("idkwhatis".to_string(), ValveKeyValueType::String("this".to_string()))
		]))
	]))
}

#[test]
fn parse_object_5() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
mykey "a value with spaces"
"#), false, 0), Ok(vec![
		ValveKeyValue::new("mykey".to_string(), ValveKeyValueType::String("a value with spaces".to_string()))
	]))
}

#[test]
fn parse_object_6() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key unquoted_value
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("unquoted_value".to_string()))
	]))
}

#[test]
fn parse_object_7() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
obj {
	key1 "quoted"
	key2 unquoted
	key3 "another quoted"
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("obj".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("key1".to_string(), ValveKeyValueType::String("quoted".to_string())),
			ValveKeyValue::new("key2".to_string(), ValveKeyValueType::String("unquoted".to_string())),
			ValveKeyValue::new("key3".to_string(), ValveKeyValueType::String("another quoted".to_string()))
		]))
	]))
}

#[test]
fn parse_object_8() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key a\"b
"#), false, 0), Err(Error::UnexpectedEndOfFile))
}

#[test]
fn parse_object_9() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
obj {
	key value	}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("obj".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("value".to_string()))
		]))
	]))
}

#[test]
fn parse_object_10() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
obj {  	
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("obj".to_string(), ValveKeyValueType::Object(Vec::new()))
	]))
}

#[test]
fn parse_object_11() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key ""
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("".to_string()))
	]))
}

#[test]
fn parse_object_12() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key "unterminated
"#), false, 0), Err(Error::UnexpectedEndOfFile))
}

#[test]
fn parse_object_13() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
outer {
	inner {
		key val
	}
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("outer".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("inner".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("val".to_string()))
			]))
		]))
	]))
}

#[test]
fn parse_object_14() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
a {
	b {
		c {
			d e
		}
	}
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("a".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("b".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("c".to_string(), ValveKeyValueType::Object(vec![
					ValveKeyValue::new("d".to_string(), ValveKeyValueType::String("e".to_string()))
				]))
			]))
		]))
	]))
}

#[test]
fn parse_object_15() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
root {
	child1 {
		x 1
	}
	child2 {
		y 2
	}
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("root".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("child1".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("x".to_string(), ValveKeyValueType::String("1".to_string()))
			])),
			ValveKeyValue::new("child2".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("y".to_string(), ValveKeyValueType::String("2".to_string()))
			]))
		]))
	]))
}

#[test]
fn parse_object_16() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
big {
	sub {
		key1 "hello world"
		key2 plain
		key3 "another"
	}
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("big".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("sub".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("key1".to_string(), ValveKeyValueType::String("hello world".to_string())),
				ValveKeyValue::new("key2".to_string(), ValveKeyValueType::String("plain".to_string())),
				ValveKeyValue::new("key3".to_string(), ValveKeyValueType::String("another".to_string()))
			]))
		]))
	]))
}

#[test]
fn parse_object_17() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
obj {
	key"withquote {
		inner val
	}
}
"#), false, 0), Err(Error::UnexpectedEndOfFile))
}

#[test]
fn parse_object_18() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
first {
	a b
}
second {
	c d
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("first".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("a".to_string(), ValveKeyValueType::String("b".to_string()))
		])),
		ValveKeyValue::new("second".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("c".to_string(), ValveKeyValueType::String("d".to_string()))
		]))
	]))
}

#[test]
fn parse_object_19() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
obj {
	x y
}
another "value"
"#), false, 0), Ok(vec![
		ValveKeyValue::new("obj".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("x".to_string(), ValveKeyValueType::String("y".to_string()))
		])),
		ValveKeyValue::new("another".to_string(), ValveKeyValueType::String("value".to_string()))
	]))
}

#[test]
fn parse_object_20() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
first "hello"
second {
	inner "world"
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("first".to_string(), ValveKeyValueType::String("hello".to_string())),
		ValveKeyValue::new("second".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("inner".to_string(), ValveKeyValueType::String("world".to_string()))
		]))
	]))
}

#[test]
fn parse_object_21() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
tabtest {
	indent1	value1
	indent2	value2
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("tabtest".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("indent1".to_string(), ValveKeyValueType::String("value1".to_string())),
			ValveKeyValue::new("indent2".to_string(), ValveKeyValueType::String("value2".to_string()))
		]))
	]))
}

#[test]
fn parse_object_22() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key
{
value
"data"
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("value".to_string(), ValveKeyValueType::String("data".to_string()))
		]))
	]))
}

#[test]
fn parse_object_23() {
	assert_eq!(parse_object(&mut TrackedChars::new("key\r\n{\r\nvalue \"data\"\r\n}\r\n"), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("value".to_string(), ValveKeyValueType::String("data".to_string()))
		]))
	]))
}

#[test]
fn parse_object_24() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
  key	 {
	value1	"a"	
	value2	 b
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("value1".to_string(), ValveKeyValueType::String("a".to_string())),
			ValveKeyValue::new("value2".to_string(), ValveKeyValueType::String("b".to_string()))
		]))
	]))
}

#[test]
fn parse_object_25() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key{inner "data"}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("inner".to_string(), ValveKeyValueType::String("data".to_string()))
		]))
	]))
}

#[test]
fn parse_object_26() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
mykey"myvalue"
"#), false, 0), Ok(vec![
		ValveKeyValue::new("mykey".to_string(), ValveKeyValueType::String("myvalue".to_string()))
	]))
}

#[test]
fn parse_object_27() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key "line1\nline2 \"quote\""
"#), true, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("line1\nline2 \"quote\"".to_string()))
	]))
}

#[test]
fn parse_object_28() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key "a\\b"
"#), true, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("a\\b".to_string()))
	]))
}

#[test]
fn parse_object_29() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
a\\b "value"
"#), true, 0), Ok(vec![
		ValveKeyValue::new("a\\b".to_string(), ValveKeyValueType::String("value".to_string()))
	]))
}

#[test]
fn parse_object_30() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
container {
	item "escaped\tvalue"
}
"#), true, 0), Ok(vec![
		ValveKeyValue::new("container".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("item".to_string(), ValveKeyValueType::String("escaped\tvalue".to_string()))
		]))
	]))
}

#[test]
fn parse_object_31() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
a {
	b {
		c "line\ncontinue"
	}
}
"#), true, 0), Ok(vec![
		ValveKeyValue::new("a".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("b".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("c".to_string(), ValveKeyValueType::String("line\ncontinue".to_string()))
			]))
		]))
	]))
}

#[test]
fn parse_object_32() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key {
	value "data"
"#), false, 0), Err(Error::UnexpectedEndOfFile))
}

#[test]
fn parse_object_33() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
obj {
	key1 "val"
	key2
}
"#), false, 0), Err(Error::MissingValue { line: 4, col: 0 }))
}

#[test]
fn parse_object_34() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
outer {
	inner "oops
}
"#), false, 0), Err(Error::UnexpectedEndOfFile))
}

#[test]
fn parse_object_35() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
weird"key {
	nested "val"
}
"#), false, 0), Err(Error::UnexpectedEndOfFile))
}

#[test]
fn parse_object_36() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
first_val plain
object_key {
	a b
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("first_val".to_string(), ValveKeyValueType::String("plain".to_string())),
		ValveKeyValue::new("object_key".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("a".to_string(), ValveKeyValueType::String("b".to_string()))
		]))
	]))
}

#[test]
fn parse_object_37() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
a "1"
b "2"
c {
	d e
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("a".to_string(), ValveKeyValueType::String("1".to_string())),
		ValveKeyValue::new("b".to_string(), ValveKeyValueType::String("2".to_string())),
		ValveKeyValue::new("c".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("d".to_string(), ValveKeyValueType::String("e".to_string()))
		]))
	]))
}

#[test]
fn parse_object_38() {
	assert_eq!(parse_object(&mut TrackedChars::new(""), false, 0), Ok(Vec::new()))
}

#[test]
fn parse_object_39() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
} "something"
"#), false, 0), Err(Error::UnexpectedEndOfObject { line: 1, col: 0 }))
}

#[test]
fn parse_object_40() {
	assert_eq!(parse_object(&mut TrackedChars::new("key {notobject"), false, 0), Err(Error::MissingValue { line: 0, col: 14 }))
}

#[test]
fn parse_object_41() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
{ {
	inner val
} }
"#), false, 0), Err(Error::UnexpectedObjectAsKey { line: 1, col: 2 }))
}

#[test]
fn parse_object_42() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#" " "data" "#), false, 0), Err(Error::UnexpectedEndOfFile))
}

#[test]
fn parse_object_43() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"\ "val""#), false, 0), Ok(vec![
		ValveKeyValue::new("\\".to_string(), ValveKeyValueType::String("val".to_string()))
	]))
}

#[test]
fn parse_object_44() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
obj {
	key value{contains}braces
}
"#), false, 0), Err(Error::MissingValue { line: 2, col: 19 }))
}

#[test]
fn parse_object_45() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
a{b{c{d e}}}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("a".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("b".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("c".to_string(), ValveKeyValueType::Object(vec![
					ValveKeyValue::new("d".to_string(), ValveKeyValueType::String("e".to_string()))
				]))
			]))
		]))
	]))
}

#[test]
fn parse_object_46() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key {
	value "{"
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("value".to_string(), ValveKeyValueType::String("{".to_string()))
		]))
	]))
}

#[test]
fn parse_object_47() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key {
	value "}"
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("value".to_string(), ValveKeyValueType::String("}".to_string()))
		]))
	]))
}

#[test]
fn parse_object_48() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"first{}second{}"#), false, 0), Ok(vec![
		ValveKeyValue::new("first".to_string(), ValveKeyValueType::Object(Vec::new())),
		ValveKeyValue::new("second".to_string(), ValveKeyValueType::Object(Vec::new()))
	]))
}

#[test]
fn parse_object_49() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key	value
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("value".to_string()))
	]))
}

#[test]
fn parse_object_50() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
container {
	child {}
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("container".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("child".to_string(), ValveKeyValueType::Object(Vec::new()))
		]))
	]))
}

#[test]
fn parse_object_51() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
a {}
b {}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("a".to_string(), ValveKeyValueType::Object(Vec::new())),
		ValveKeyValue::new("b".to_string(), ValveKeyValueType::Object(Vec::new()))
	]))
}

#[test]
fn parse_object_52() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key "a\\\"b"
"#), true, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("a\\\"b".to_string()))
	]))
}

#[test]
fn parse_object_53() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key123 "number-like key"
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key123".to_string(), ValveKeyValueType::String("number-like key".to_string()))
	]))
}

#[test]
fn parse_object_54() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key "unfinished\
"#), true, 0), Err(Error::UnexpectedEndOfFile))
}

#[test]
fn parse_object_55() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key { value "deep"
"#), false, 0), Err(Error::UnexpectedEndOfFile))
}

#[test]
fn parse_object_56() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key { }
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::Object(Vec::new()))
	]))
}

#[test]
fn parse_object_57() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
key {
	sub "text\\\"more\""
}
"#), true, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("sub".to_string(), ValveKeyValueType::String("text\\\"more\"".to_string()))
		]))
	]))
}

#[test]
fn parse_object_58() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"
root {
	branch {
		leaf "done"
	}
	branch2 "simple"
}
"#), false, 0), Ok(vec![
		ValveKeyValue::new("root".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("branch".to_string(), ValveKeyValueType::Object(vec![
				ValveKeyValue::new("leaf".to_string(), ValveKeyValueType::String("done".to_string()))
			])),
			ValveKeyValue::new("branch2".to_string(), ValveKeyValueType::String("simple".to_string()))
		]))
	]))
}