| #![allow( |
| clippy::float_cmp, |
| clippy::needless_lifetimes, |
| clippy::needless_raw_string_hashes, |
| clippy::non_ascii_literal, |
| clippy::single_match_else, |
| clippy::uninlined_format_args |
| )] |
| |
| #[macro_use] |
| mod macros; |
| |
| use proc_macro2::{Delimiter, Group, Literal, Span, TokenStream, TokenTree}; |
| use quote::ToTokens; |
| use std::ffi::CStr; |
| use std::str::FromStr; |
| use syn::{Lit, LitFloat, LitInt, LitStr}; |
| |
| #[track_caller] |
| fn lit(s: &str) -> Lit { |
| let mut tokens = TokenStream::from_str(s).unwrap().into_iter(); |
| match tokens.next().unwrap() { |
| TokenTree::Literal(lit) => { |
| assert!(tokens.next().is_none()); |
| Lit::new(lit) |
| } |
| wrong => panic!("{:?}", wrong), |
| } |
| } |
| |
| #[test] |
| fn strings() { |
| #[track_caller] |
| fn test_string(s: &str, value: &str) { |
| let s = s.trim(); |
| match lit(s) { |
| Lit::Str(lit) => { |
| assert_eq!(lit.value(), value); |
| let again = lit.into_token_stream().to_string(); |
| if again != s { |
| test_string(&again, value); |
| } |
| } |
| wrong => panic!("{:?}", wrong), |
| } |
| } |
| |
| test_string(r#" "" "#, ""); |
| test_string(r#" "a" "#, "a"); |
| test_string(r#" "\n" "#, "\n"); |
| test_string(r#" "\r" "#, "\r"); |
| test_string(r#" "\t" "#, "\t"); |
| test_string(r#" "🐕" "#, "🐕"); // NOTE: This is an emoji |
| test_string(r#" "\"" "#, "\""); |
| test_string(r#" "'" "#, "'"); |
| test_string(r#" "\u{1F415}" "#, "\u{1F415}"); |
| test_string(r#" "\u{1_2__3_}" "#, "\u{123}"); |
| test_string( |
| "\"contains\nnewlines\\\nescaped newlines\"", |
| "contains\nnewlinesescaped newlines", |
| ); |
| test_string( |
| "\"escaped newline\\\n \x0C unsupported whitespace\"", |
| "escaped newline\x0C unsupported whitespace", |
| ); |
| test_string("r\"raw\nstring\\\nhere\"", "raw\nstring\\\nhere"); |
| test_string("\"...\"q", "..."); |
| test_string("r\"...\"q", "..."); |
| test_string("r##\"...\"##q", "..."); |
| } |
| |
| #[test] |
| fn byte_strings() { |
| #[track_caller] |
| fn test_byte_string(s: &str, value: &[u8]) { |
| let s = s.trim(); |
| match lit(s) { |
| Lit::ByteStr(lit) => { |
| assert_eq!(lit.value(), value); |
| let again = lit.into_token_stream().to_string(); |
| if again != s { |
| test_byte_string(&again, value); |
| } |
| } |
| wrong => panic!("{:?}", wrong), |
| } |
| } |
| |
| test_byte_string(r#" b"" "#, b""); |
| test_byte_string(r#" b"a" "#, b"a"); |
| test_byte_string(r#" b"\n" "#, b"\n"); |
| test_byte_string(r#" b"\r" "#, b"\r"); |
| test_byte_string(r#" b"\t" "#, b"\t"); |
| test_byte_string(r#" b"\"" "#, b"\""); |
| test_byte_string(r#" b"'" "#, b"'"); |
| test_byte_string( |
| "b\"contains\nnewlines\\\nescaped newlines\"", |
| b"contains\nnewlinesescaped newlines", |
| ); |
| test_byte_string("br\"raw\nstring\\\nhere\"", b"raw\nstring\\\nhere"); |
| test_byte_string("b\"...\"q", b"..."); |
| test_byte_string("br\"...\"q", b"..."); |
| test_byte_string("br##\"...\"##q", b"..."); |
| } |
| |
| #[test] |
| fn c_strings() { |
| #[track_caller] |
| fn test_c_string(s: &str, value: &CStr) { |
| let s = s.trim(); |
| match lit(s) { |
| Lit::CStr(lit) => { |
| assert_eq!(*lit.value(), *value); |
| let again = lit.into_token_stream().to_string(); |
| if again != s { |
| test_c_string(&again, value); |
| } |
| } |
| wrong => panic!("{:?}", wrong), |
| } |
| } |
| |
| test_c_string(r#" c"" "#, c""); |
| test_c_string(r#" c"a" "#, c"a"); |
| test_c_string(r#" c"\n" "#, c"\n"); |
| test_c_string(r#" c"\r" "#, c"\r"); |
| test_c_string(r#" c"\t" "#, c"\t"); |
| test_c_string(r#" c"\\" "#, c"\\"); |
| test_c_string(r#" c"\'" "#, c"'"); |
| test_c_string(r#" c"\"" "#, c"\""); |
| test_c_string( |
| "c\"contains\nnewlines\\\nescaped newlines\"", |
| c"contains\nnewlinesescaped newlines", |
| ); |
| test_c_string("cr\"raw\nstring\\\nhere\"", c"raw\nstring\\\nhere"); |
| test_c_string("c\"...\"q", c"..."); |
| test_c_string("cr\"...\"", c"..."); |
| test_c_string("cr##\"...\"##", c"..."); |
| test_c_string( |
| r#" c"hello\x80我叫\u{1F980}" "#, // from the RFC |
| c"hello\x80我叫\u{1F980}", |
| ); |
| } |
| |
| #[test] |
| fn bytes() { |
| #[track_caller] |
| fn test_byte(s: &str, value: u8) { |
| let s = s.trim(); |
| match lit(s) { |
| Lit::Byte(lit) => { |
| assert_eq!(lit.value(), value); |
| let again = lit.into_token_stream().to_string(); |
| assert_eq!(again, s); |
| } |
| wrong => panic!("{:?}", wrong), |
| } |
| } |
| |
| test_byte(r#" b'a' "#, b'a'); |
| test_byte(r#" b'\n' "#, b'\n'); |
| test_byte(r#" b'\r' "#, b'\r'); |
| test_byte(r#" b'\t' "#, b'\t'); |
| test_byte(r#" b'\'' "#, b'\''); |
| test_byte(r#" b'"' "#, b'"'); |
| test_byte(r#" b'a'q "#, b'a'); |
| } |
| |
| #[test] |
| fn chars() { |
| #[track_caller] |
| fn test_char(s: &str, value: char) { |
| let s = s.trim(); |
| match lit(s) { |
| Lit::Char(lit) => { |
| assert_eq!(lit.value(), value); |
| let again = lit.into_token_stream().to_string(); |
| if again != s { |
| test_char(&again, value); |
| } |
| } |
| wrong => panic!("{:?}", wrong), |
| } |
| } |
| |
| test_char(r#" 'a' "#, 'a'); |
| test_char(r#" '\n' "#, '\n'); |
| test_char(r#" '\r' "#, '\r'); |
| test_char(r#" '\t' "#, '\t'); |
| test_char(r#" '🐕' "#, '🐕'); // NOTE: This is an emoji |
| test_char(r#" '\'' "#, '\''); |
| test_char(r#" '"' "#, '"'); |
| test_char(r#" '\u{1F415}' "#, '\u{1F415}'); |
| test_char(r#" 'a'q "#, 'a'); |
| } |
| |
| #[test] |
| fn ints() { |
| #[track_caller] |
| fn test_int(s: &str, value: u64, suffix: &str) { |
| match lit(s) { |
| Lit::Int(lit) => { |
| assert_eq!(lit.base10_digits().parse::<u64>().unwrap(), value); |
| assert_eq!(lit.suffix(), suffix); |
| let again = lit.into_token_stream().to_string(); |
| if again != s { |
| test_int(&again, value, suffix); |
| } |
| } |
| wrong => panic!("{:?}", wrong), |
| } |
| } |
| |
| test_int("5", 5, ""); |
| test_int("5u32", 5, "u32"); |
| test_int("0E", 0, "E"); |
| test_int("0ECMA", 0, "ECMA"); |
| test_int("0o0A", 0, "A"); |
| test_int("5_0", 50, ""); |
| test_int("5_____0_____", 50, ""); |
| test_int("0x7f", 127, ""); |
| test_int("0x7F", 127, ""); |
| test_int("0b1001", 9, ""); |
| test_int("0o73", 59, ""); |
| test_int("0x7Fu8", 127, "u8"); |
| test_int("0b1001i8", 9, "i8"); |
| test_int("0o73u32", 59, "u32"); |
| test_int("0x__7___f_", 127, ""); |
| test_int("0x__7___F_", 127, ""); |
| test_int("0b_1_0__01", 9, ""); |
| test_int("0o_7__3", 59, ""); |
| test_int("0x_7F__u8", 127, "u8"); |
| test_int("0b__10__0_1i8", 9, "i8"); |
| test_int("0o__7__________________3u32", 59, "u32"); |
| test_int("0e1\u{5c5}", 0, "e1\u{5c5}"); |
| } |
| |
| #[test] |
| fn floats() { |
| #[track_caller] |
| fn test_float(s: &str, value: f64, suffix: &str) { |
| match lit(s) { |
| Lit::Float(lit) => { |
| assert_eq!(lit.base10_digits().parse::<f64>().unwrap(), value); |
| assert_eq!(lit.suffix(), suffix); |
| let again = lit.into_token_stream().to_string(); |
| if again != s { |
| test_float(&again, value, suffix); |
| } |
| } |
| wrong => panic!("{:?}", wrong), |
| } |
| } |
| |
| test_float("5.5", 5.5, ""); |
| test_float("5.5E12", 5.5e12, ""); |
| test_float("5.5e12", 5.5e12, ""); |
| test_float("1.0__3e-12", 1.03e-12, ""); |
| test_float("1.03e+12", 1.03e12, ""); |
| test_float("9e99e99", 9e99, "e99"); |
| test_float("1e_0", 1.0, ""); |
| test_float("0.0ECMA", 0.0, "ECMA"); |
| } |
| |
| #[test] |
| fn negative() { |
| let span = Span::call_site(); |
| assert_eq!("-1", LitInt::new("-1", span).to_string()); |
| assert_eq!("-1i8", LitInt::new("-1i8", span).to_string()); |
| assert_eq!("-1i16", LitInt::new("-1i16", span).to_string()); |
| assert_eq!("-1i32", LitInt::new("-1i32", span).to_string()); |
| assert_eq!("-1i64", LitInt::new("-1i64", span).to_string()); |
| assert_eq!("-1.5", LitFloat::new("-1.5", span).to_string()); |
| assert_eq!("-1.5f32", LitFloat::new("-1.5f32", span).to_string()); |
| assert_eq!("-1.5f64", LitFloat::new("-1.5f64", span).to_string()); |
| } |
| |
| #[test] |
| fn suffix() { |
| #[track_caller] |
| fn get_suffix(token: &str) -> String { |
| let lit = syn::parse_str::<Lit>(token).unwrap(); |
| match lit { |
| Lit::Str(lit) => lit.suffix().to_owned(), |
| Lit::ByteStr(lit) => lit.suffix().to_owned(), |
| Lit::CStr(lit) => lit.suffix().to_owned(), |
| Lit::Byte(lit) => lit.suffix().to_owned(), |
| Lit::Char(lit) => lit.suffix().to_owned(), |
| Lit::Int(lit) => lit.suffix().to_owned(), |
| Lit::Float(lit) => lit.suffix().to_owned(), |
| _ => unimplemented!(), |
| } |
| } |
| |
| assert_eq!(get_suffix("\"\"s"), "s"); |
| assert_eq!(get_suffix("r\"\"r"), "r"); |
| assert_eq!(get_suffix("r#\"\"#r"), "r"); |
| assert_eq!(get_suffix("b\"\"b"), "b"); |
| assert_eq!(get_suffix("br\"\"br"), "br"); |
| assert_eq!(get_suffix("br#\"\"#br"), "br"); |
| assert_eq!(get_suffix("c\"\"c"), "c"); |
| assert_eq!(get_suffix("cr\"\"cr"), "cr"); |
| assert_eq!(get_suffix("cr#\"\"#cr"), "cr"); |
| assert_eq!(get_suffix("'c'c"), "c"); |
| assert_eq!(get_suffix("b'b'b"), "b"); |
| assert_eq!(get_suffix("1i32"), "i32"); |
| assert_eq!(get_suffix("1_i32"), "i32"); |
| assert_eq!(get_suffix("1.0f32"), "f32"); |
| assert_eq!(get_suffix("1.0_f32"), "f32"); |
| } |
| |
| #[test] |
| fn test_deep_group_empty() { |
| let tokens = TokenStream::from_iter([TokenTree::Group(Group::new( |
| Delimiter::None, |
| TokenStream::from_iter([TokenTree::Group(Group::new( |
| Delimiter::None, |
| TokenStream::from_iter([TokenTree::Literal(Literal::string("hi"))]), |
| ))]), |
| ))]); |
| |
| snapshot!(tokens as Lit, @r#""hi""# ); |
| } |
| |
| #[test] |
| fn test_error() { |
| let err = syn::parse_str::<LitStr>("...").unwrap_err(); |
| assert_eq!("expected string literal", err.to_string()); |
| |
| let err = syn::parse_str::<LitStr>("5").unwrap_err(); |
| assert_eq!("expected string literal", err.to_string()); |
| } |
