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 skip_comments_1() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"// comment
key value"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("value".to_string()))
	]))
}

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

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

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

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

#[test]
fn skip_comments_6() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"// only comment"#), false, 0), Ok(vec![]))
}

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

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

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

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

#[test]
fn skip_comments_11() {
	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 skip_comments_12() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"key // comment
"value""#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("value".to_string()))
	]))
}

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

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

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

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

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

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

#[test]
fn skip_comments_19() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"// top comment
key1 val1
// middle comment
key2 val2
// bottom comment"#), false, 0), Ok(vec![
		ValveKeyValue::new("key1".to_string(), ValveKeyValueType::String("val1".to_string())),
		ValveKeyValue::new("key2".to_string(), ValveKeyValueType::String("val2".to_string()))
	]))
}

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

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

#[test]
fn skip_comments_22() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"// こんにちは
key val"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("val".to_string()))
	]))
}

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

#[test]
fn skip_comments_24() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"// comment before escaped value
key "escaped\tval""#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("escaped\\tval".to_string()))
	]))
}

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

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

#[test]
fn skip_comments_27() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"key// comment
value"#), false, 0), Err(Error::MissingValue { line: 1, col: 5 }))
}

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

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

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

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

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

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

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

#[test]
fn skip_comments_35() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"key value// comment
"#), false, 0), Err(Error::MissingValue { line: 1, col: 0 }))
}

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

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

#[test]
fn skip_comments_38() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"key // comment
"#), false, 0), Err(Error::MissingValue { line: 1, col: 0 }))
}

#[test]
fn skip_comments_39() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"obj { key // comment
"#), false, 0), Err(Error::MissingValue { line: 1, col: 0 }))
}

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

#[test]
fn skip_comments_41() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"// comment /* not block */
key val"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("val".to_string()))
	]))
}

#[test]
fn skip_comments_42() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"// comment
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 skip_comments_43() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"//c1

//c2
key val"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("val".to_string()))
	]))
}

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

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

#[test]
fn skip_comments_46() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"// file header
obj {
// member comment
inner val
}
// end comment"#), false, 0), Ok(vec![
		ValveKeyValue::new("obj".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("inner".to_string(), ValveKeyValueType::String("val".to_string()))
		]))
	]))
}

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

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

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

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

#[test]
fn skip_comments_51() {
	let long_comment = format!("// {}\nkey val", "a".repeat(1000));
	assert_eq!(parse_object(&mut TrackedChars::new(&long_comment), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("val".to_string()))
	]))
}

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

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

#[test]
fn skip_comments_54() {
	assert_eq!(parse_object(&mut TrackedChars::new("// comment\r\n// another\r\nkey val\r\n"), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("val".to_string()))
	]))
}

#[test]
fn skip_comments_55() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"key "value\\n" // comment
"#), true, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("value\\n".to_string()))
	]))
}

#[test]
fn skip_comments_56() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"// top
outer {
// mid
inner1 val1
inner2 val2
// inner bottom
}
// bottom"#), false, 0), Ok(vec![
		ValveKeyValue::new("outer".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("inner1".to_string(), ValveKeyValueType::String("val1".to_string())),
			ValveKeyValue::new("inner2".to_string(), ValveKeyValueType::String("val2".to_string()))
		]))
	]))
}

#[test]
fn skip_comments_57() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"key value // comment with special chars !@#$%^&*()
"#), false, 0), Ok(vec![
		ValveKeyValue::new("key".to_string(), ValveKeyValueType::String("value".to_string()))
	]))
}

#[test]
fn skip_comments_58() {
	assert_eq!(parse_object(&mut TrackedChars::new(r#"// starting comment
first "simple"
// between
second {
  // inside
  inner "deep"
  // after inner
}
// ending"#), false, 0), Ok(vec![
		ValveKeyValue::new("first".to_string(), ValveKeyValueType::String("simple".to_string())),
		ValveKeyValue::new("second".to_string(), ValveKeyValueType::Object(vec![
			ValveKeyValue::new("inner".to_string(), ValveKeyValueType::String("deep".to_string()))
		]))
	]))
}