From d56f60c05f316ab4cc37ebe7a9ad4caf91a75de6 Mon Sep 17 00:00:00 2001 From: mat Date: Sun, 9 Jan 2022 15:40:54 -0600 Subject: [PATCH] add all the string reader tests --- azalea-brigadier/src/string_reader.rs | 402 +++++++++++++++++++++++++- 1 file changed, 393 insertions(+), 9 deletions(-) diff --git a/azalea-brigadier/src/string_reader.rs b/azalea-brigadier/src/string_reader.rs index 28823bce..f32de473 100644 --- a/azalea-brigadier/src/string_reader.rs +++ b/azalea-brigadier/src/string_reader.rs @@ -91,7 +91,7 @@ impl StringReader<'_> { } } - pub fn read_int(&mut self) -> Result<(), CommandSyntaxException> { + pub fn read_int(&mut self) -> Result { let start = self.cursor; while self.can_read() && StringReader::<'_>::is_allowed_number(self.peek()) { self.skip(); @@ -109,10 +109,10 @@ impl StringReader<'_> { .create_with_context(self)); } - Ok(()) + Ok(result.unwrap()) } - pub fn read_long(&mut self) -> Result<(), CommandSyntaxException> { + pub fn read_long(&mut self) -> Result { let start = self.cursor; while self.can_read() && StringReader::<'_>::is_allowed_number(self.peek()) { self.skip(); @@ -130,12 +130,12 @@ impl StringReader<'_> { .create_with_context(self)); } - Ok(()) + Ok(result.unwrap()) } - pub fn read_double(&mut self) -> Result<(), CommandSyntaxException> { + pub fn read_double(&mut self) -> Result { let start = self.cursor; - while self.can_read() && StringReader::<'_>::is_allowed_number(self.peek()) { + while self.can_read() && StringReader::is_allowed_number(self.peek()) { self.skip(); } let number = &self.string[start..self.cursor]; @@ -151,10 +151,10 @@ impl StringReader<'_> { .create_with_context(self)); } - Ok(()) + Ok(result.unwrap()) } - pub fn read_float(&mut self) -> Result<(), CommandSyntaxException> { + pub fn read_float(&mut self) -> Result { let start = self.cursor; while self.can_read() && StringReader::<'_>::is_allowed_number(self.peek()) { self.skip(); @@ -172,7 +172,7 @@ impl StringReader<'_> { .create_with_context(self)); } - Ok(()) + Ok(result.unwrap()) } pub fn is_allowed_in_unquoted_string(c: char) -> bool { @@ -504,4 +504,388 @@ mod test { assert_eq!(e.cursor(), Some(0)); } } + + #[test] + fn read_quoted_string_no_close() { + let mut reader = StringReader::from("\"hello world"); + let result = reader.read_quoted_string(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!(e.get_type(), &BuiltInExceptions::ReaderExpectedEndOfQuote); + assert_eq!(e.cursor(), Some(12)); + } + } + + #[test] + fn read_quoted_string_invalid_escape() { + let mut reader = StringReader::from("\"hello\\nworld\""); + let result = reader.read_quoted_string(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!( + e.get_type(), + &BuiltInExceptions::ReaderInvalidEscape { character: 'n' } + ); + assert_eq!(e.cursor(), Some(7)); + } + } + + #[test] + fn read_quoted_string_invalid_quote_escape() { + let mut reader = StringReader::from("'hello\\\"\'world"); + let result = reader.read_quoted_string(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!( + e.get_type(), + &BuiltInExceptions::ReaderInvalidEscape { character: '"' } + ); + assert_eq!(e.cursor(), Some(7)); + } + } + + #[test] + fn read_string_no_quotes() { + let mut reader = StringReader::from("hello world"); + assert_eq!(reader.read_string().unwrap(), "hello"); + assert_eq!(reader.get_read(), "hello"); + assert_eq!(reader.remaining(), " world"); + } + + #[test] + fn read_string_single_quotes() { + let mut reader = StringReader::from("'hello world'"); + assert_eq!(reader.read_string().unwrap(), "hello world"); + assert_eq!(reader.get_read(), "'hello world'"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_string_double_quotes() { + let mut reader = StringReader::from("\"hello world\""); + assert_eq!(reader.read_string().unwrap(), "hello world"); + assert_eq!(reader.get_read(), "\"hello world\""); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_int() { + let mut reader = StringReader::from("1234567890"); + assert_eq!(reader.read_int().unwrap(), 1234567890); + assert_eq!(reader.get_read(), "1234567890"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_int_negative() { + let mut reader = StringReader::from("-1234567890"); + assert_eq!(reader.read_int().unwrap(), -1234567890); + assert_eq!(reader.get_read(), "-1234567890"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_int_invalid() { + let mut reader = StringReader::from("12.34"); + let result = reader.read_int(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!( + e.get_type(), + &BuiltInExceptions::ReaderInvalidInt { + value: "12.34".to_string() + } + ); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn read_int_none() { + let mut reader = StringReader::from(""); + let result = reader.read_int(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!(e.get_type(), &BuiltInExceptions::ReaderExpectedInt); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn read_int_with_remaining() { + let mut reader = StringReader::from("1234567890 foo bar"); + assert_eq!(reader.read_int().unwrap(), 1234567890); + assert_eq!(reader.get_read(), "1234567890"); + assert_eq!(reader.remaining(), " foo bar"); + } + + #[test] + fn read_int_with_remaining_immediate() { + let mut reader = StringReader::from("1234567890foo bar"); + assert_eq!(reader.read_int().unwrap(), 1234567890); + assert_eq!(reader.get_read(), "1234567890"); + assert_eq!(reader.remaining(), "foo bar"); + } + + #[test] + fn read_long() { + let mut reader = StringReader::from("1234567890"); + assert_eq!(reader.read_long().unwrap(), 1234567890); + assert_eq!(reader.get_read(), "1234567890"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_long_negative() { + let mut reader = StringReader::from("-1234567890"); + assert_eq!(reader.read_long().unwrap(), -1234567890); + assert_eq!(reader.get_read(), "-1234567890"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_long_invalid() { + let mut reader = StringReader::from("12.34"); + let result = reader.read_long(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!( + e.get_type(), + &BuiltInExceptions::ReaderInvalidLong { + value: "12.34".to_string() + } + ); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn read_long_none() { + let mut reader = StringReader::from(""); + let result = reader.read_long(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!(e.get_type(), &BuiltInExceptions::ReaderExpectedLong); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn read_long_with_remaining() { + let mut reader = StringReader::from("1234567890 foo bar"); + assert_eq!(reader.read_long().unwrap(), 1234567890); + assert_eq!(reader.get_read(), "1234567890"); + assert_eq!(reader.remaining(), " foo bar"); + } + + #[test] + fn read_long_with_remaining_immediate() { + let mut reader = StringReader::from("1234567890foo bar"); + assert_eq!(reader.read_long().unwrap(), 1234567890); + assert_eq!(reader.get_read(), "1234567890"); + assert_eq!(reader.remaining(), "foo bar"); + } + + #[test] + fn read_double() { + let mut reader = StringReader::from("123"); + assert_eq!(reader.read_double().unwrap(), 123.0); + assert_eq!(reader.get_read(), "123"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_double_with_decimal() { + let mut reader = StringReader::from("12.34"); + assert_eq!(reader.read_double().unwrap(), 12.34); + assert_eq!(reader.get_read(), "12.34"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_double_negative() { + let mut reader = StringReader::from("-123"); + assert_eq!(reader.read_double().unwrap(), -123.0); + assert_eq!(reader.get_read(), "-123"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_double_invalid() { + let mut reader = StringReader::from("12.34.56"); + let result = reader.read_double(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!( + e.get_type(), + &BuiltInExceptions::ReaderInvalidDouble { + value: "12.34.56".to_string() + } + ); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn read_double_none() { + let mut reader = StringReader::from(""); + let result = reader.read_double(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!(e.get_type(), &BuiltInExceptions::ReaderExpectedDouble); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn read_double_with_remaining() { + let mut reader = StringReader::from("12.34 foo bar"); + assert_eq!(reader.read_double().unwrap(), 12.34); + assert_eq!(reader.get_read(), "12.34"); + assert_eq!(reader.remaining(), " foo bar"); + } + + #[test] + fn read_double_with_remaining_immediate() { + let mut reader = StringReader::from("12.34foo bar"); + assert_eq!(reader.read_double().unwrap(), 12.34); + assert_eq!(reader.get_read(), "12.34"); + assert_eq!(reader.remaining(), "foo bar"); + } + + #[test] + fn read_float() { + let mut reader = StringReader::from("123"); + assert_eq!(reader.read_float().unwrap(), 123.0f32); + assert_eq!(reader.get_read(), "123"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_float_with_decimal() { + let mut reader = StringReader::from("12.34"); + assert_eq!(reader.read_float().unwrap(), 12.34f32); + assert_eq!(reader.get_read(), "12.34"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_float_negative() { + let mut reader = StringReader::from("-123"); + assert_eq!(reader.read_float().unwrap(), -123.0f32); + assert_eq!(reader.get_read(), "-123"); + assert_eq!(reader.remaining(), ""); + } + + #[test] + fn read_float_invalid() { + let mut reader = StringReader::from("12.34.56"); + let result = reader.read_float(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!( + e.get_type(), + &BuiltInExceptions::ReaderInvalidFloat { + value: "12.34.56".to_string() + } + ); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn read_float_none() { + let mut reader = StringReader::from(""); + let result = reader.read_float(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!(e.get_type(), &BuiltInExceptions::ReaderExpectedFloat); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn read_float_with_remaining() { + let mut reader = StringReader::from("12.34 foo bar"); + assert_eq!(reader.read_float().unwrap(), 12.34f32); + assert_eq!(reader.get_read(), "12.34"); + assert_eq!(reader.remaining(), " foo bar"); + } + + #[test] + fn read_float_with_remaining_immediate() { + let mut reader = StringReader::from("12.34foo bar"); + assert_eq!(reader.read_float().unwrap(), 12.34f32); + assert_eq!(reader.get_read(), "12.34"); + assert_eq!(reader.remaining(), "foo bar"); + } + + #[test] + fn expect_correct() { + let mut reader = StringReader::from("abc"); + reader.expect('a'); + assert_eq!(reader.cursor(), 1); + } + + #[test] + fn expect_incorrect() { + let mut reader = StringReader::from("bcd"); + let result = reader.expect('a'); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!( + e.get_type(), + &BuiltInExceptions::ReaderExpectedSymbol { symbol: 'a' } + ); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn expect_none() { + let mut reader = StringReader::from(""); + let result = reader.expect('a'); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!( + e.get_type(), + &BuiltInExceptions::ReaderExpectedSymbol { symbol: 'a' } + ); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn read_boolean_correct() { + let mut reader = StringReader::from("true"); + assert_eq!(reader.read_boolean().unwrap(), true); + assert_eq!(reader.get_read(), "true"); + } + + #[test] + fn read_boolean_incorrect() { + let mut reader = StringReader::from("tuesday"); + let result = reader.read_boolean(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!( + e.get_type(), + &BuiltInExceptions::ReaderInvalidBool { + value: "tuesday".to_string() + } + ); + assert_eq!(e.cursor(), Some(0)); + } + } + + #[test] + fn read_boolean_none() { + let mut reader = StringReader::from(""); + let result = reader.read_boolean(); + assert!(result.is_err()); + if let Err(e) = result { + assert_eq!(e.get_type(), &BuiltInExceptions::ReaderExpectedBool); + assert_eq!(e.cursor(), Some(0)); + } + } }