Lines Matching refs:assert_eq
35 //! assert_eq!((e1 | e2), Flags::ABC); // union
36 //! assert_eq!((e1 & e2), Flags::C); // intersection
37 //! assert_eq!((e1 - e2), Flags::A); // set difference
38 //! assert_eq!(!e2, Flags::A); // set complement
77 //! assert_eq!(format!("{}", flags), "hi!");
78 //! assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
79 //! assert_eq!(format!("{:?}", Flags::B), "B");
217 //! assert_eq!(derived_default.bits(), 0);
243 //! assert_eq!(implemented_default, (Flags::A | Flags::C));
305 /// assert_eq!((e1 | e2), Flags::ABC); // union
306 /// assert_eq!((e1 & e2), Flags::C); // intersection
307 /// assert_eq!((e1 - e2), Flags::A); // set difference
308 /// assert_eq!(!e2, Flags::A); // set complement
344 /// assert_eq!(format!("{}", flags), "hi!");
345 /// assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
346 /// assert_eq!(format!("{:?}", Flags::B), "B");
984 assert_eq!(Flags::empty().bits(), 0b00000000);
985 assert_eq!(Flags::A.bits(), 0b00000001);
986 assert_eq!(Flags::ABC.bits(), 0b00000111);
988 assert_eq!(AnotherSetOfFlags::empty().bits(), 0b00);
989 assert_eq!(AnotherSetOfFlags::ANOTHER_FLAG.bits(), !0_i8);
991 assert_eq!(EmptyFlags::empty().bits(), 0b00000000);
996 assert_eq!(Flags::from_bits(0), Some(Flags::empty()));
997 assert_eq!(Flags::from_bits(0b1), Some(Flags::A));
998 assert_eq!(Flags::from_bits(0b10), Some(Flags::B));
999 assert_eq!(Flags::from_bits(0b11), Some(Flags::A | Flags::B));
1000 assert_eq!(Flags::from_bits(0b1000), None);
1002 assert_eq!(
1007 assert_eq!(EmptyFlags::from_bits(0), Some(EmptyFlags::empty()));
1008 assert_eq!(EmptyFlags::from_bits(0b1), None);
1013 assert_eq!(Flags::from_bits_truncate(0), Flags::empty());
1014 assert_eq!(Flags::from_bits_truncate(0b1), Flags::A);
1015 assert_eq!(Flags::from_bits_truncate(0b10), Flags::B);
1016 assert_eq!(Flags::from_bits_truncate(0b11), (Flags::A | Flags::B));
1017 assert_eq!(Flags::from_bits_truncate(0b1000), Flags::empty());
1018 assert_eq!(Flags::from_bits_truncate(0b1001), Flags::A);
1020 assert_eq!(
1025 assert_eq!(EmptyFlags::from_bits_truncate(0), EmptyFlags::empty());
1026 assert_eq!(EmptyFlags::from_bits_truncate(0b1), EmptyFlags::empty());
1032 assert_eq!(unsafe { Flags::from_bits_unchecked(0) }, Flags::empty());
1033 assert_eq!(unsafe { Flags::from_bits_unchecked(0b1) }, Flags::A);
1034 assert_eq!(unsafe { Flags::from_bits_unchecked(0b10) }, Flags::B);
1036 assert_eq!(
1040 assert_eq!(
1044 assert_eq!(
1050 assert_eq!(
1133 assert_eq!(e1, e2);
1137 assert_eq!(e3, AnotherSetOfFlags::ANOTHER_FLAG);
1145 assert_eq!(e1, Flags::B);
1149 assert_eq!(e3, AnotherSetOfFlags::empty());
1156 assert_eq!((e1 | e2), Flags::ABC); // union
1157 assert_eq!((e1 & e2), Flags::C); // intersection
1158 assert_eq!((e1 - e2), Flags::A); // set difference
1159 assert_eq!(!e2, Flags::A); // set complement
1160 assert_eq!(e1 ^ e2, Flags::A | Flags::B); // toggle
1163 assert_eq!(e3, Flags::A | Flags::B);
1167 assert_eq!(m4, AnotherSetOfFlags::empty());
1175 assert_eq!((e1 | e2), (Flags::ABC | extra)); // union
1176 assert_eq!((e1 & e2), Flags::C); // intersection
1177 assert_eq!((e1 - e2), (Flags::A | extra)); // set difference
1178 assert_eq!(!e2, Flags::A); // set complement
1179 assert_eq!(!e1, Flags::B); // set complement
1180 assert_eq!(e1 ^ e2, Flags::A | Flags::B | extra); // toggle
1183 assert_eq!(e3, Flags::A | Flags::B | extra);
1191 assert_eq!(ab.bits, 0b011);
1192 assert_eq!(bc.bits, 0b110);
1193 assert_eq!(ac.bits, 0b101);
1195 assert_eq!(ab, Flags::B.union(Flags::A));
1196 assert_eq!(ac, Flags::C.union(Flags::A));
1197 assert_eq!(bc, Flags::C.union(Flags::B));
1199 assert_eq!(ac, Flags::A | Flags::C);
1200 assert_eq!(bc, Flags::B | Flags::C);
1201 assert_eq!(ab.union(bc), Flags::ABC);
1203 assert_eq!(ac, Flags::A | Flags::C);
1204 assert_eq!(bc, Flags::B | Flags::C);
1206 assert_eq!(ac.union(bc), ac | bc);
1207 assert_eq!(ac.union(bc), Flags::ABC);
1208 assert_eq!(bc.union(ac), Flags::ABC);
1210 assert_eq!(ac.intersection(bc), ac & bc);
1211 assert_eq!(ac.intersection(bc), Flags::C);
1212 assert_eq!(bc.intersection(ac), Flags::C);
1214 assert_eq!(ac.difference(bc), ac - bc);
1215 assert_eq!(bc.difference(ac), bc - ac);
1216 assert_eq!(ac.difference(bc), Flags::A);
1217 assert_eq!(bc.difference(ac), Flags::B);
1219 assert_eq!(bc.complement(), !bc);
1220 assert_eq!(bc.complement(), Flags::A);
1221 assert_eq!(ac.symmetric_difference(bc), Flags::A.union(Flags::B));
1222 assert_eq!(bc.symmetric_difference(ac), Flags::A.union(Flags::B));
1234 assert_eq!(INTERSECT, Flags::C);
1235 assert_eq!(UNION, Flags::A | Flags::C);
1236 assert_eq!(DIFFERENCE, Flags::all() - Flags::A);
1237 assert_eq!(COMPLEMENT, !Flags::C);
1238 assert_eq!(SYM_DIFFERENCE, (Flags::A | Flags::C) ^ (Flags::all() - Flags::A));
1246 assert_eq!(e1.bits, 0b1101);
1247 assert_eq!(e1.union(e2), (Flags::ABC | extra));
1248 assert_eq!(e1.intersection(e2), Flags::C);
1249 assert_eq!(e1.difference(e2), Flags::A | extra);
1250 assert_eq!(e2.difference(e1), Flags::B);
1251 assert_eq!(e2.complement(), Flags::A);
1252 assert_eq!(e1.complement(), Flags::B);
1253 assert_eq!(e1.symmetric_difference(e2), Flags::A | Flags::B | extra); // toggle
1281 assert_eq!(
1287 assert_eq!(a.complement(), !a, "named != op: !({:?})", a);
1291 assert_eq!(
1298 assert_eq!(
1305 assert_eq!(
1312 assert_eq!(
1320 assert_eq!(
1329 assert_eq!(a.union(b), a | b, "named != op: `{:?}` | `{:?}`", a, b,);
1330 assert_eq!(
1337 assert_eq!(
1344 assert_eq!(a.difference(b), a - b, "named != op: `{:?}` - `{:?}`", a, b,);
1346 assert_eq!(b.difference(a), b - a, "named != op: `{:?}` - `{:?}`", b, a,);
1349 assert_eq!(a.union(b), b.union(a), "asymmetry: `{:?}` | `{:?}`", a, b,);
1350 assert_eq!(
1357 assert_eq!(
1374 assert_eq!(e1, Flags::A | Flags::B);
1383 assert_eq!(m1, Flags::A);
1386 assert_eq!(m1, Flags::A);
1389 assert_eq!(m1, Flags::empty());
1392 assert_eq!(m1, e1);
1400 assert_eq!(M2, Flags::A);
1403 assert_eq!(M3, Flags::C);
1412 assert_eq!(flags, Flags::empty());
1416 assert_eq!(flags, Flags::A | Flags::B);
1420 assert_eq!(flags, Flags::A | Flags::B);
1424 assert_eq!(flags, Flags::ABC);
1429 assert_eq!([].iter().cloned().collect::<Flags>(), Flags::empty());
1430 assert_eq!(
1434 assert_eq!(
1478 assert_eq!(hash(&x), hash(&y));
1481 assert_eq!(hash(&x), hash(&y));
1486 assert_eq!(Flags::empty(), Flags::default());
1491 assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
1492 assert_eq!(format!("{:?}", Flags::empty()), "(empty)");
1493 assert_eq!(format!("{:?}", Flags::ABC), "A | B | C | ABC");
1495 assert_eq!(format!("{:?}", extra), "0xb8");
1496 assert_eq!(format!("{:?}", Flags::A | extra), "A | 0xb8");
1498 assert_eq!(
1503 assert_eq!(format!("{:?}", EmptyFlags::empty()), "(empty)");
1508 assert_eq!(format!("{:b}", Flags::ABC), "111");
1509 assert_eq!(format!("{:#b}", Flags::ABC), "0b111");
1511 assert_eq!(format!("{:b}", Flags::ABC | extra), "1010111");
1512 assert_eq!(format!("{:#b}", Flags::ABC | extra), "0b1010111");
1517 assert_eq!(format!("{:o}", LongFlags::LONG_A), "177777");
1518 assert_eq!(format!("{:#o}", LongFlags::LONG_A), "0o177777");
1520 assert_eq!(format!("{:o}", LongFlags::LONG_A | extra), "5177777");
1521 assert_eq!(format!("{:#o}", LongFlags::LONG_A | extra), "0o5177777");
1526 assert_eq!(format!("{:x}", LongFlags::LONG_A), "ffff");
1527 assert_eq!(format!("{:#x}", LongFlags::LONG_A), "0xffff");
1529 assert_eq!(format!("{:x}", LongFlags::LONG_A | extra), "e0ffff");
1530 assert_eq!(format!("{:#x}", LongFlags::LONG_A | extra), "0xe0ffff");
1535 assert_eq!(format!("{:X}", LongFlags::LONG_A), "FFFF");
1536 assert_eq!(format!("{:#X}", LongFlags::LONG_A), "0xFFFF");
1538 assert_eq!(format!("{:X}", LongFlags::LONG_A | extra), "E0FFFF");
1539 assert_eq!(format!("{:#X}", LongFlags::LONG_A | extra), "0xE0FFFF");
1590 assert_eq!(Flags::all(), Flags::A);
1591 assert_eq!(format!("{:?}", Flags::A), "A");
1614 assert_eq!(module::Test::FOO.bits(), 1);
1643 assert_eq!(module::value(), 1)
1659 assert_eq!(format!("{:?}", Flags::empty()), "NONE");
1660 assert_eq!(format!("{:?}", Flags::SOME), "SOME");
1679 assert_eq!(Flags128::ABC, Flags128::A | Flags128::B | Flags128::C);
1680 assert_eq!(Flags128::A.bits, 0x0000_0000_0000_0000_0000_0000_0000_0001);
1681 assert_eq!(Flags128::B.bits, 0x0000_0000_0000_1000_0000_0000_0000_0000);
1682 assert_eq!(Flags128::C.bits, 0x8000_0000_0000_0000_0000_0000_0000_0000);
1683 assert_eq!(
1687 assert_eq!(format!("{:?}", Flags128::A), "A");
1688 assert_eq!(format!("{:?}", Flags128::B), "B");
1689 assert_eq!(format!("{:?}", Flags128::C), "C");
1690 assert_eq!(format!("{:?}", Flags128::ABC), "A | B | C | ABC");
1699 assert_eq!(serialized, r#"{"bits":3}"#);
1708 assert_eq!(deserialized.bits, expected.bits);
1717 assert_eq!(deserialized.bits, flags.bits);