register_allocator/fuzz/fuzz_targets/loc_set_ops.rs

   1 #![no_main]
   2 use bigint_presentation_code_register_allocator::{loc::Loc, loc_set::LocSet};
   3 use libfuzzer_sys::fuzz_target;
   4 use std::{
   5     collections::HashSet,
   6     ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Sub, SubAssign},
   7 };
   8
   9 fn check_op(
  10     lhs_hash_set: &HashSet<Loc>,
  11     rhs_hash_set: &HashSet<Loc>,
  12     op: impl Fn(LocSet, LocSet) -> LocSet,
  13     expected: impl IntoIterator<Item = Loc>,
  14 ) {
  15     let lhs = LocSet::from_iter(lhs_hash_set.iter().copied());
  16     let rhs = LocSet::from_iter(rhs_hash_set.iter().copied());
  17     let result = op(lhs, rhs);
  18     let result: Vec<Loc> = result.iter().collect();
  19     let mut expected = Vec::from_iter(expected);
  20     expected.sort();
  21     assert_eq!(result, expected);
  22 }
  23
  24 macro_rules! check_all_op_combos {
  25     (
  26         $lhs_hash_set:expr, $rhs_hash_set:expr, $expected:expr,
  27         $bin_op:ident::$bin_op_fn:ident(),
  28         $bin_assign_op:ident::$bin_assign_op_fn:ident(),
  29         $(
  30             #[rev]
  31             $bin_assign_rev_op_fn:ident(),
  32         )?
  33     ) => {
  34         check_op(
  35             $lhs_hash_set,
  36             $rhs_hash_set,
  37             |lhs, rhs| $bin_op::$bin_op_fn(lhs, rhs),
  38             $expected,
  39         );
  40         check_op(
  41             $lhs_hash_set,
  42             $rhs_hash_set,
  43             |lhs, rhs| $bin_op::$bin_op_fn(&lhs, rhs),
  44             $expected,
  45         );
  46         check_op(
  47             $lhs_hash_set,
  48             $rhs_hash_set,
  49             |lhs, rhs| $bin_op::$bin_op_fn(lhs, &rhs),
  50             $expected,
  51         );
  52         check_op(
  53             $lhs_hash_set,
  54             $rhs_hash_set,
  55             |lhs, rhs| $bin_op::$bin_op_fn(&lhs, &rhs),
  56             $expected,
  57         );
  58         check_op(
  59             $lhs_hash_set,
  60             $rhs_hash_set,
  61             |mut lhs, rhs| {
  62                 $bin_assign_op::$bin_assign_op_fn(&mut lhs, &rhs);
  63                 lhs
  64             },
  65             $expected,
  66         );
  67         check_op(
  68             $lhs_hash_set,
  69             $rhs_hash_set,
  70             |mut lhs, rhs| {
  71                 $bin_assign_op::$bin_assign_op_fn(&mut lhs, rhs);
  72                 lhs
  73             },
  74             $expected,
  75         );
  76         $(check_op(
  77             $lhs_hash_set,
  78             $rhs_hash_set,
  79             |lhs, mut rhs| {
  80                 rhs.$bin_assign_rev_op_fn(&lhs);
  81                 lhs
  82             },
  83             $expected,
  84         );)?
  85     };
  86 }
  87
  88 fuzz_target!(|data: (HashSet<Loc>, HashSet<Loc>)| {
  89     let (lhs_hash_set, rhs_hash_set) = data;
  90     check_all_op_combos!(
  91         &lhs_hash_set,
  92         &rhs_hash_set,
  93         lhs_hash_set.intersection(&rhs_hash_set).copied(),
  94         BitAnd::bitand(),
  95         BitAndAssign::bitand_assign(),
  96     );
  97     check_all_op_combos!(
  98         &lhs_hash_set,
  99         &rhs_hash_set,
 100         lhs_hash_set.union(&rhs_hash_set).copied(),
 101         BitOr::bitor(),
 102         BitOrAssign::bitor_assign(),
 103     );
 104     check_all_op_combos!(
 105         &lhs_hash_set,
 106         &rhs_hash_set,
 107         lhs_hash_set.symmetric_difference(&rhs_hash_set).copied(),
 108         BitXor::bitxor(),
 109         BitXorAssign::bitxor_assign(),
 110     );
 111     check_all_op_combos!(
 112         &lhs_hash_set,
 113         &rhs_hash_set,
 114         lhs_hash_set.difference(&rhs_hash_set).copied(),
 115         Sub::sub(),
 116         SubAssign::sub_assign(),
 117     );
 118 });