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     let lhs = LocSet::from_iter(lhs_hash_set.iter().copied());
  91     let rhs = LocSet::from_iter(rhs_hash_set.iter().copied());
  92     check_all_op_combos!(
  93         &lhs_hash_set,
  94         &rhs_hash_set,
  95         lhs_hash_set.intersection(&rhs_hash_set).copied(),
  96         BitAnd::bitand(),
  97         BitAndAssign::bitand_assign(),
  98     );
  99     check_all_op_combos!(
 100         &lhs_hash_set,
 101         &rhs_hash_set,
 102         lhs_hash_set.union(&rhs_hash_set).copied(),
 103         BitOr::bitor(),
 104         BitOrAssign::bitor_assign(),
 105     );
 106     check_all_op_combos!(
 107         &lhs_hash_set,
 108         &rhs_hash_set,
 109         lhs_hash_set.symmetric_difference(&rhs_hash_set).copied(),
 110         BitXor::bitxor(),
 111         BitXorAssign::bitxor_assign(),
 112     );
 113     check_all_op_combos!(
 114         &lhs_hash_set,
 115         &rhs_hash_set,
 116         lhs_hash_set.difference(&rhs_hash_set).copied(),
 117         Sub::sub(),
 118         SubAssign::sub_assign(),
 119     );
 120 });