lib/Fuzzer/test/FuzzerFnAdapterUnittest.cpp

   1 #include "FuzzerFnAdapter.h"
   2 #include "gtest/gtest-spi.h"
   3 #include "gtest/gtest.h"
   4
   5 namespace fuzzer {
   6 namespace impl {
   7
   8 template <typename... Args>
   9 bool Unpack(std::tuple<Args...> *Tuple, std::initializer_list<uint8_t> data) {
  10   std::vector<uint8_t> V(data);
  11   return Unpack(V.data(), V.size(), Tuple);
  12 }
  13
  14 TEST(Unpack, Bool) {
  15   std::tuple<bool> T;
  16   EXPECT_TRUE(Unpack(&T, {1}));
  17   EXPECT_TRUE(std::get<0>(T));
  18
  19   EXPECT_TRUE(Unpack(&T, {0}));
  20   EXPECT_FALSE(std::get<0>(T));
  21
  22   EXPECT_FALSE(Unpack(&T, {}));
  23 }
  24
  25 TEST(Unpack, BoolBool) {
  26   std::tuple<bool, bool> T;
  27   EXPECT_TRUE(Unpack(&T, {1, 0}));
  28   EXPECT_TRUE(std::get<0>(T));
  29   EXPECT_FALSE(std::get<1>(T));
  30
  31   EXPECT_TRUE(Unpack(&T, {0, 1}));
  32   EXPECT_FALSE(std::get<0>(T));
  33   EXPECT_TRUE(std::get<1>(T));
  34
  35   EXPECT_FALSE(Unpack(&T, {}));
  36   EXPECT_FALSE(Unpack(&T, {10}));
  37 }
  38
  39 TEST(Unpack, BoolInt) {
  40   std::tuple<bool, int> T;
  41   EXPECT_TRUE(Unpack(&T, {1, 16, 2, 0, 0}));
  42   EXPECT_TRUE(std::get<0>(T));
  43   EXPECT_EQ(528, std::get<1>(T));
  44
  45   EXPECT_FALSE(Unpack(&T, {1, 2}));
  46 }
  47
  48 TEST(Unpack, Vector) {
  49   std::tuple<std::vector<uint8_t>> T;
  50   const auto &V = std::get<0>(T);
  51
  52   EXPECT_FALSE(Unpack(&T, {}));
  53
  54   EXPECT_TRUE(Unpack(&T, {0}));
  55   EXPECT_EQ(0ul, V.size());
  56
  57   EXPECT_TRUE(Unpack(&T, {0, 1, 2, 3}));
  58   EXPECT_EQ(0ul, V.size());
  59
  60   EXPECT_TRUE(Unpack(&T, {2}));
  61   EXPECT_EQ(0ul, V.size());
  62
  63   EXPECT_TRUE(Unpack(&T, {2, 3}));
  64   EXPECT_EQ(1ul, V.size());
  65   EXPECT_EQ(3, V[0]);
  66
  67   EXPECT_TRUE(Unpack(&T, {2, 9, 8}));
  68   EXPECT_EQ(2ul, V.size());
  69   EXPECT_EQ(9, V[0]);
  70   EXPECT_EQ(8, V[1]);
  71 }
  72
  73 TEST(Unpack, String) {
  74   std::tuple<std::string> T;
  75   const auto &S = std::get<0>(T);
  76
  77   EXPECT_TRUE(Unpack(&T, {2, 3}));
  78   EXPECT_EQ(1ul, S.size());
  79   EXPECT_EQ(3, S[0]);
  80 }
  81
  82 template <typename Fn>
  83 bool UnpackAndApply(Fn F, std::initializer_list<uint8_t> Data) {
  84   std::vector<uint8_t> V(Data);
  85   return UnpackAndApply(F, V.data(), V.size());
  86 }
  87
  88 static void fnBool(bool b) { EXPECT_TRUE(b); }
  89
  90 TEST(Apply, Bool) {
  91   EXPECT_FALSE(UnpackAndApply(fnBool, {}));
  92   EXPECT_TRUE(UnpackAndApply(fnBool, {1}));
  93   EXPECT_NONFATAL_FAILURE(UnpackAndApply(fnBool, {0}),
  94                           "Actual: false\nExpected: true");
  95 }
  96
  97 static void fnInt(int i) { EXPECT_EQ(42, i); }
  98
  99 TEST(Apply, Int) {
 100   EXPECT_FALSE(UnpackAndApply(fnInt, {}));
 101   EXPECT_TRUE(UnpackAndApply(fnInt, {42, 0, 0, 0}));
 102   EXPECT_NONFATAL_FAILURE(UnpackAndApply(fnInt, {10, 0, 0, 0}),
 103                           "Actual: 10\nExpected: 42");
 104 }
 105
 106 } // namespace impl
 107 } // namespace fuzzer