use ingraph_codegen::flags::{BitWidth, FlagsModel};
use quote::quote;
fn parse(input: &syn::DeriveInput, args: proc_macro2::TokenStream) -> syn::Result<FlagsModel> {
super::parse(input, &crate::host::options(args))
}
fn refusal(input: &syn::DeriveInput, args: proc_macro2::TokenStream) -> String {
parse(input, args)
.expect_err("the declaration is refused")
.into_iter()
.map(|error| error.to_string())
.collect::<Vec<_>>()
.join(" | ")
}
fn idents(model: &FlagsModel) -> Vec<String> {
model.bits.iter().map(|bit| bit.ident.to_string()).collect()
}
fn rendered(tokens: impl quote::ToTokens) -> String {
tokens.to_token_stream().to_string().replace(' ', "")
}
#[test]
fn a_bare_manifest_is_a_name_a_width_and_its_bits() {
let model = parse(
&syn::parse_quote! {
pub enum Disposition {
Default = 0x1,
Forced = 0x2,
HearingImpaired = 0x4,
}
},
quote!(u32),
)
.expect("unit variants with explicit values is the whole shape");
assert_eq!(model.name, "Disposition");
assert_eq!(model.width, BitWidth::U32);
assert_eq!(rendered(&model.krate), "::ingraph");
assert_eq!(rendered(&model.vis), "pub");
assert_eq!(idents(&model), ["Default", "Forced", "HearingImpaired"]);
assert_eq!(
model.bits.iter().map(|bit| bit.value).collect::<Vec<_>>(),
[0x1, 0x2, 0x4]
);
assert_eq!(
model.bits.iter().map(|bit| bit.word()).collect::<Vec<_>>(),
["DEFAULT", "FORCED", "HEARING_IMPAIRED"]
);
assert_eq!(
model.bits.iter().map(|bit| bit.field()).collect::<Vec<_>>(),
["default", "forced", "hearingImpaired"]
);
}
#[test]
fn a_rename_moves_the_word_and_the_wire_field_together() {
let model = parse(
&syn::parse_quote! {
enum Disposition {
Default = 0x1,
#[ingraph(rename = "COMMENT")]
Commentary = 0x2,
}
},
quote!(u32),
)
.expect("a bit names the word it is spelled with");
assert_eq!(model.bits[1].rename.as_deref(), Some("COMMENT"));
assert_eq!(model.bits[1].word(), "COMMENT");
assert_eq!(
model.bits[1].field(),
"comment",
"the field follows the word, not the identifier"
);
assert_eq!(model.bits[0].word(), "DEFAULT");
}
#[test]
fn a_bit_may_be_written_as_a_shift() {
let model = parse(
&syn::parse_quote! {
enum Disposition {
Default = 1 << 0,
Forced = (1 << 1),
HearingImpaired = 1 << 2,
Commentary = 0b1000,
}
},
quote!(u32),
)
.expect("a shift of a literal is a value this door can evaluate");
assert_eq!(
model.bits.iter().map(|bit| bit.value).collect::<Vec<_>>(),
[0x1, 0x2, 0x4, 0x8]
);
}
#[test]
fn every_width_the_table_carries_is_one_a_declaration_may_write() {
for width in BitWidth::ALL {
let word = syn::Ident::new(width.as_str(), proc_macro2::Span::call_site());
let model = parse(
&syn::parse_quote! {
enum Channel { Left = 0x1 }
},
quote!(#word),
)
.expect("every width this kind carries is one a declaration may write");
assert_eq!(model.width, width, "{}", width.as_str());
}
}
#[test]
fn the_crate_path_overrides_the_default() {
let model = parse(
&syn::parse_quote! {
enum Channel { Left = 0x1 }
},
quote!(u16, crate = "shim::ingraph"),
)
.expect("a re-export shim is a path like any other");
assert_eq!(rendered(&model.krate), "shim::ingraph");
assert_eq!(model.width, BitWidth::U16);
}
#[test]
fn the_authors_own_attributes_survive_on_the_item_and_on_a_bit() {
let model = parse(
&syn::parse_quote! {
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub enum Disposition {
#[ingraph(rename = "DEFAULT")]
Default = 0x1,
}
},
quote!(u32),
)
.expect("attributes this door does not own are not this door's to read");
let item = model.attrs.iter().map(rendered).collect::<Vec<_>>();
assert_eq!(
item,
[
"#[doc=r\"Thedispositionsatrackmaycarry.\"]",
"#[derive(Debug,Clone,Copy)]",
"#[non_exhaustive]"
]
);
let bit = model.bits[0].attrs.iter().map(rendered).collect::<Vec<_>>();
assert_eq!(
bit,
["#[doc=r\"Thedefaulttrackforitskind.\"]"],
"the marker this door read is gone, and nothing else is"
);
}
#[test]
fn refuses_a_declaration_that_names_no_width() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1 }
},
quote!(),
);
assert!(refused.contains("names its WIDTH"), "{refused}");
assert!(refused.contains("`u8`, `u16`, `u32`"), "{refused}");
}
#[test]
fn refuses_a_width_the_carrier_table_does_not_hold() {
for word in super::UNCARRIED {
let name = syn::Ident::new(word, proc_macro2::Span::call_site());
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1 }
},
quote!(#name),
);
assert!(
refused.contains("is not a width a flags set can be stored at"),
"{word}: {refused}"
);
}
let signed = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1 }
},
quote!(i32),
);
assert!(signed.contains("`iN`'s top bit is negative"), "{signed}");
}
#[test]
fn refuses_a_width_declared_twice() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1 }
},
quote!(u32, u16),
);
assert!(
refused.contains("the width is declared more than once"),
"{refused}"
);
}
#[test]
fn refuses_an_entry_a_flags_declaration_does_not_take() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1 }
},
quote!(u32, sqlite(text)),
);
assert!(
refused.contains("unknown entry in `#[ingraph::flags(…)]`"),
"{refused}"
);
}
#[test]
fn refuses_a_crate_declared_twice_and_a_crate_that_is_not_a_path() {
let twice = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1 }
},
quote!(u32, crate = "a", crate = "b"),
);
assert!(
twice.contains("`crate` is declared more than once"),
"{twice}"
);
let unquoted = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1 }
},
quote!(u32, crate = ingraph),
);
assert!(
unquoted.contains("must be a path to the `ingraph` crate"),
"{unquoted}"
);
}
#[test]
fn refuses_an_option_block_left_beside_the_declaration() {
let refused = refusal(
&syn::parse_quote! {
#[ingraph(crate = "shim::ingraph")]
enum Disposition { Default = 0x1 }
},
quote!(u32),
);
assert!(
refused.contains("options are the MACRO's arguments"),
"{refused}"
);
assert!(
refused.contains("`#[ingraph::flags(u32)]`"),
"the sentence names THIS door and not the record's: {refused}"
);
}
#[test]
fn refuses_a_declaration_that_is_not_an_enum() {
let refused = refusal(
&syn::parse_quote! {
struct Disposition { bits: u32 }
},
quote!(u32),
);
assert!(refused.contains("supports enums only"), "{refused}");
}
#[test]
fn refuses_an_enum_with_no_variants() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition {}
},
quote!(u32),
);
assert!(refused.contains("declares no flags"), "{refused}");
}
#[test]
fn refuses_every_variant_that_carries_data() {
let refused = refusal(
&syn::parse_quote! {
enum Shape { Unit = 0x1, Tuple(u8), Named { width: u8 } }
},
quote!(u32),
);
assert!(refused.contains("`Tuple` carries data"), "{refused}");
assert!(refused.contains("`Named` carries data"), "{refused}");
}
#[test]
fn refuses_a_generic_flags_set() {
for input in [
syn::parse_quote! {
enum Disposition<T> { Default = 0x1 }
},
syn::parse_quote! {
enum Disposition<'a> { Default = 0x1 }
},
syn::parse_quote! {
enum Disposition where Self: Sized { Default = 0x1 }
},
] {
let refused = refusal(&input, quote!(u32));
assert!(refused.contains("generic flags sets"), "{refused}");
}
}
#[test]
fn refuses_a_bit_that_names_no_number() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Default, Forced }
},
quote!(u32),
);
assert!(refused.contains("`Default` names no bit"), "{refused}");
assert!(refused.contains("`Forced` names no bit"), "{refused}");
assert!(refused.contains("reordering the declaration"), "{refused}");
}
#[test]
fn refuses_a_bit_whose_value_is_zero() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { None = 0, Default = 0x1 }
},
quote!(u32),
);
assert!(refused.contains("`None` is `0`"), "{refused}");
assert!(refused.contains("EMPTY set"), "{refused}");
}
#[test]
fn refuses_a_value_past_the_declared_width() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1, Ninth = 0x100 }
},
quote!(u8),
);
assert!(refused.contains("`0x100` does not fit `u8`"), "{refused}");
assert!(refused.contains("numbers 8 bits"), "{refused}");
assert!(refused.contains("`0x80`"), "{refused}");
parse(
&syn::parse_quote! {
enum Disposition { Ninth = 0x100 }
},
quote!(u16),
)
.expect("the same value is the ninth bit of a wider column");
}
#[test]
fn refuses_a_composite_mask() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1, Forced = 0x2, Either = 0x3 }
},
quote!(u32),
);
assert!(refused.contains("`0x3` sets 2 bits"), "{refused}");
assert!(refused.contains("a declared flag is ONE bit"), "{refused}");
}
#[test]
fn refuses_a_value_this_door_cannot_evaluate() {
for expression in [
quote!(FORCED_BIT),
quote!(1 + 1),
quote!(Self::DEFAULT.bits()),
quote!(1 << 128),
] {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Default = #expression }
},
quote!(u32),
);
assert!(
refused.contains("an integer LITERAL or a shift of one"),
"{expression}: {refused}"
);
}
}
#[test]
fn refuses_two_bits_on_one_value() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1, Primary = 1 << 0 }
},
quote!(u32),
);
assert!(
refused.contains("`Primary` and `Default` are both bit `0x1`"),
"{refused}"
);
}
#[test]
fn refuses_two_bits_on_one_word() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition {
#[ingraph(rename = "FORCED")]
Default = 0x1,
Forced = 0x2,
}
},
quote!(u32),
);
assert!(
refused.contains("`Forced` and `Default` are both `FORCED` as a word"),
"{refused}"
);
}
#[test]
fn refuses_two_bits_on_one_wire_field() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition {
#[ingraph(rename = "FOO_BAR")]
Default = 0x1,
#[ingraph(rename = "FooBar")]
Forced = 0x2,
}
},
quote!(u32),
);
assert!(
refused.contains("`Forced` and `Default` are both `fooBar` as a wire field"),
"{refused}"
);
assert!(
!refused.contains("as a word"),
"two spellings are two words: {refused}"
);
}
#[test]
fn refuses_a_rename_that_is_not_a_graphql_name() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition {
#[ingraph(rename = "hearing impaired")]
HearingImpaired = 0x1,
}
},
quote!(u32),
);
assert!(
refused.contains("`hearing impaired` is not a GraphQL name"),
"{refused}"
);
}
#[test]
fn refuses_a_rename_that_is_a_rust_keyword() {
for keyword in ["type", "const", "move", "fn"] {
let word = syn::LitStr::new(keyword, proc_macro2::Span::call_site());
let refused = refusal(
&syn::parse_quote! {
enum Disposition {
#[ingraph(rename = #word)]
Default = 0x1,
}
},
quote!(u32),
);
assert!(
refused.contains("is not usable as a Rust identifier"),
"`{keyword}`: {refused}"
);
}
}
#[test]
fn a_rename_legal_in_both_grammars_is_taken() {
let model = parse(
&syn::parse_quote! {
enum Disposition {
#[ingraph(rename = "TYPE_HINT")]
Default = 0x1,
}
},
quote!(u32),
)
.expect("`TYPE_HINT` is a GraphQL name and a Rust identifier");
assert_eq!(model.bits[0].word(), "TYPE_HINT");
assert_eq!(model.bits[0].field(), "typeHint");
}
#[test]
fn refuses_a_type_name_that_is_not_a_graphql_name() {
let refused = refusal(
&syn::parse_quote! {
enum Dispositión { Default = 0x1 }
},
quote!(u32),
);
assert!(refused.contains("is not a GraphQL name"), "{refused}");
}
#[test]
fn refuses_a_rename_declared_twice_or_written_as_something_else() {
let twice = refusal(
&syn::parse_quote! {
enum Disposition {
#[ingraph(rename = "A", rename = "B")]
Default = 0x1,
}
},
quote!(u32),
);
assert!(
twice.contains("`rename` is declared more than once"),
"{twice}"
);
let unquoted = refusal(
&syn::parse_quote! {
enum Disposition {
#[ingraph(rename = DEFAULT)]
Default = 0x1,
}
},
quote!(u32),
);
assert!(unquoted.contains("must be a string literal"), "{unquoted}");
}
#[test]
fn refuses_an_entry_a_bit_does_not_take() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition {
#[ingraph(sqlite(rename = "d"))]
Default = 0x1,
}
},
quote!(u32),
);
assert!(
refused.contains("unknown entry in `#[ingraph(…)]` on a flag"),
"{refused}"
);
}
#[test]
fn one_pass_reports_every_bit_it_can_still_see() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition {
Default,
Forced = 0,
HearingImpaired = 0x3,
Commentary = 0x100,
Original = 0x8,
}
},
quote!(u8),
);
assert!(refused.contains("`Default` names no bit"), "{refused}");
assert!(refused.contains("`Forced` is `0`"), "{refused}");
assert!(refused.contains("`0x3` sets 2 bits"), "{refused}");
assert!(refused.contains("`0x100` does not fit `u8`"), "{refused}");
assert_eq!(
refused.matches(" | ").count(),
3,
"four refusals and no more — the legal bit is not one of them: {refused}"
);
}
#[test]
fn one_pass_reports_the_grammar_and_the_shape_together() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Tuple(u8) }
},
quote!(u32, sqlite),
);
assert!(
refused.contains("unknown entry in `#[ingraph::flags(…)]`"),
"{refused}"
);
assert!(refused.contains("`Tuple` carries data"), "{refused}");
}
#[test]
fn a_mirror_names_an_upstream_and_keeps_its_own_words() {
let model = parse(
&syn::parse_quote! {
pub enum Disposition {
Default = 0x1,
#[ingraph(rename = "HEARING_IMPAIRED")]
Hi = 0x4,
}
},
quote!(u32, remote = "upstream::Disposition"),
)
.expect("a mirror is a manifest with an upstream named beside it");
assert_eq!(
rendered(model.remote.as_ref().expect("the upstream")),
"upstream::Disposition"
);
assert_eq!(
model
.bits
.iter()
.map(|bit| bit.upstream().to_string())
.collect::<Vec<_>>(),
["DEFAULT", "HEARING_IMPAIRED"],
"the knob names the upstream `const`, and a bit that shares its name inherits it"
);
assert_eq!(
model.bits.iter().map(|bit| bit.word()).collect::<Vec<_>>(),
["DEFAULT", "HI"],
"and moves no word of this declaration's"
);
assert_eq!(
model.bits.iter().map(|bit| bit.field()).collect::<Vec<_>>(),
["default", "hi"]
);
assert!(model.bits.iter().all(|bit| bit.rename.is_none()));
}
#[test]
fn a_declaration_naming_no_upstream_carries_none() {
let model = parse(
&syn::parse_quote! {
pub enum Disposition {
#[ingraph(rename = "COMMENT")]
Commentary = 0x8,
}
},
quote!(u32),
)
.expect("the ordinary declaration");
assert!(model.remote.is_none());
assert!(model.bits[0].upstream.is_none());
assert_eq!(
model.bits[0].word(),
"COMMENT",
"and its `rename` still moves the word"
);
}
#[test]
fn refuses_a_mirrors_rename_that_names_no_const() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition {
#[ingraph(rename = "not a const")]
Default = 0x1,
}
},
quote!(u32, remote = "upstream::Disposition"),
);
assert!(
refused.contains("it names the UPSTREAM `const` this bit restates"),
"{refused}"
);
}
#[test]
fn refuses_a_second_upstream() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition {
#[ingraph(rename = "DEFAULT", rename = "FORCED")]
Default = 0x1,
}
},
quote!(u32, remote = "a::One", remote = "b::Other"),
);
assert!(
refused.contains("one declaration mirrors one flags set"),
"{refused}"
);
assert!(
refused.contains("one bit restates one upstream `const`"),
"{refused}"
);
}
#[test]
fn refuses_an_upstream_that_is_not_a_path() {
let refused = refusal(
&syn::parse_quote! {
enum Disposition { Default = 0x1 }
},
quote!(u32, remote = "not a path"),
);
assert!(
refused.contains("must be a path to the flags set this one mirrors"),
"{refused}"
);
}
#[test]
fn the_wire_name_is_the_declarations_and_the_bitflags_type_keeps_its_own() {
let model = parse(
&syn::parse_quote! {
pub enum TrackDispositionFlags { Default = 0x1, Forced = 0x2 }
},
quote::quote!(u32, graphql(rename = "TrackDisposition")),
)
.expect("a width and a name");
assert_eq!(model.sdl_name(), "TrackDisposition");
assert_eq!(
model.name, "TrackDispositionFlags",
"the minted Rust type keeps the declaration's own name"
);
}
#[test]
fn the_wire_name_defaults_to_the_rust_name() {
let model = parse(
&syn::parse_quote! {
pub enum Disposition { Default = 0x1 }
},
quote::quote!(u32),
)
.expect("a width is the whole requirement");
assert_eq!(model.wire_name, None);
assert_eq!(model.sdl_name(), "Disposition");
}
#[test]
fn the_wire_name_rides_the_name_grammar_alone() {
let refused = refusal(
&syn::parse_quote! {
pub enum Disposition { Default = 0x1 }
},
quote::quote!(u32, graphql(rename = "Not A Name")),
);
assert!(refused.contains("is not a GraphQL name"), "{refused}");
let keyword = parse(
&syn::parse_quote! {
pub enum Disposition { Default = 0x1 }
},
quote::quote!(u32, graphql(rename = "type")),
)
.expect("a schema name has no Rust item behind it");
assert_eq!(keyword.sdl_name(), "type");
}
#[test]
fn refuses_a_wire_name_written_twice_or_not_at_all() {
let twice = refusal(
&syn::parse_quote! {
pub enum Disposition { Default = 0x1 }
},
quote::quote!(u32, graphql(rename = "A", rename = "B")),
);
assert!(
twice.contains("`rename` is declared more than once"),
"{twice}"
);
let empty = refusal(
&syn::parse_quote! {
pub enum Disposition { Default = 0x1 }
},
quote::quote!(u32, graphql),
);
assert!(empty.contains("`graphql(…)` needs `rename"), "{empty}");
}