1 #include "FuzzerInternal.h"
2 #include "gtest/gtest.h"
3 #include <set>
4 
5 using namespace fuzzer;
6 
7 // For now, have LLVMFuzzerTestOneInput just to make it link.
8 // Later we may want to make unittests that actually call LLVMFuzzerTestOneInput.
LLVMFuzzerTestOneInput(const uint8_t * Data,size_t Size)9 extern "C" void LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
10   abort();
11 }
12 
TEST(Fuzzer,CrossOver)13 TEST(Fuzzer, CrossOver) {
14   FuzzerRandomLibc Rand(0);
15   MutationDispatcher MD(Rand);
16   Unit A({0, 1, 2}), B({5, 6, 7});
17   Unit C;
18   Unit Expected[] = {
19        { 0 },
20        { 0, 1 },
21        { 0, 5 },
22        { 0, 1, 2 },
23        { 0, 1, 5 },
24        { 0, 5, 1 },
25        { 0, 5, 6 },
26        { 0, 1, 2, 5 },
27        { 0, 1, 5, 2 },
28        { 0, 1, 5, 6 },
29        { 0, 5, 1, 2 },
30        { 0, 5, 1, 6 },
31        { 0, 5, 6, 1 },
32        { 0, 5, 6, 7 },
33        { 0, 1, 2, 5, 6 },
34        { 0, 1, 5, 2, 6 },
35        { 0, 1, 5, 6, 2 },
36        { 0, 1, 5, 6, 7 },
37        { 0, 5, 1, 2, 6 },
38        { 0, 5, 1, 6, 2 },
39        { 0, 5, 1, 6, 7 },
40        { 0, 5, 6, 1, 2 },
41        { 0, 5, 6, 1, 7 },
42        { 0, 5, 6, 7, 1 },
43        { 0, 1, 2, 5, 6, 7 },
44        { 0, 1, 5, 2, 6, 7 },
45        { 0, 1, 5, 6, 2, 7 },
46        { 0, 1, 5, 6, 7, 2 },
47        { 0, 5, 1, 2, 6, 7 },
48        { 0, 5, 1, 6, 2, 7 },
49        { 0, 5, 1, 6, 7, 2 },
50        { 0, 5, 6, 1, 2, 7 },
51        { 0, 5, 6, 1, 7, 2 },
52        { 0, 5, 6, 7, 1, 2 }
53   };
54   for (size_t Len = 1; Len < 8; Len++) {
55     std::set<Unit> FoundUnits, ExpectedUnitsWitThisLength;
56     for (int Iter = 0; Iter < 3000; Iter++) {
57       C.resize(Len);
58       size_t NewSize = MD.CrossOver(A.data(), A.size(), B.data(), B.size(),
59                                     C.data(), C.size());
60       C.resize(NewSize);
61       FoundUnits.insert(C);
62     }
63     for (const Unit &U : Expected)
64       if (U.size() <= Len)
65         ExpectedUnitsWitThisLength.insert(U);
66     EXPECT_EQ(ExpectedUnitsWitThisLength, FoundUnits);
67   }
68 }
69 
TEST(Fuzzer,Hash)70 TEST(Fuzzer, Hash) {
71   uint8_t A[] = {'a', 'b', 'c'};
72   fuzzer::Unit U(A, A + sizeof(A));
73   EXPECT_EQ("a9993e364706816aba3e25717850c26c9cd0d89d", fuzzer::Hash(U));
74   U.push_back('d');
75   EXPECT_EQ("81fe8bfe87576c3ecb22426f8e57847382917acf", fuzzer::Hash(U));
76 }
77 
78 typedef size_t (MutationDispatcher::*Mutator)(uint8_t *Data, size_t Size,
79                                               size_t MaxSize);
80 
TestEraseByte(Mutator M,int NumIter)81 void TestEraseByte(Mutator M, int NumIter) {
82   uint8_t REM0[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
83   uint8_t REM1[8] = {0x00, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
84   uint8_t REM2[8] = {0x00, 0x11, 0x33, 0x44, 0x55, 0x66, 0x77};
85   uint8_t REM3[8] = {0x00, 0x11, 0x22, 0x44, 0x55, 0x66, 0x77};
86   uint8_t REM4[8] = {0x00, 0x11, 0x22, 0x33, 0x55, 0x66, 0x77};
87   uint8_t REM5[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x66, 0x77};
88   uint8_t REM6[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x77};
89   uint8_t REM7[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
90   FuzzerRandomLibc Rand(0);
91   MutationDispatcher MD(Rand);
92   int FoundMask = 0;
93   for (int i = 0; i < NumIter; i++) {
94     uint8_t T[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
95     size_t NewSize = (MD.*M)(T, sizeof(T), sizeof(T));
96     if (NewSize == 7 && !memcmp(REM0, T, 7)) FoundMask |= 1 << 0;
97     if (NewSize == 7 && !memcmp(REM1, T, 7)) FoundMask |= 1 << 1;
98     if (NewSize == 7 && !memcmp(REM2, T, 7)) FoundMask |= 1 << 2;
99     if (NewSize == 7 && !memcmp(REM3, T, 7)) FoundMask |= 1 << 3;
100     if (NewSize == 7 && !memcmp(REM4, T, 7)) FoundMask |= 1 << 4;
101     if (NewSize == 7 && !memcmp(REM5, T, 7)) FoundMask |= 1 << 5;
102     if (NewSize == 7 && !memcmp(REM6, T, 7)) FoundMask |= 1 << 6;
103     if (NewSize == 7 && !memcmp(REM7, T, 7)) FoundMask |= 1 << 7;
104   }
105   EXPECT_EQ(FoundMask, 255);
106 }
107 
TEST(FuzzerMutate,EraseByte1)108 TEST(FuzzerMutate, EraseByte1) {
109   TestEraseByte(&MutationDispatcher::Mutate_EraseByte, 100);
110 }
TEST(FuzzerMutate,EraseByte2)111 TEST(FuzzerMutate, EraseByte2) {
112   TestEraseByte(&MutationDispatcher::Mutate, 1000);
113 }
114 
TestInsertByte(Mutator M,int NumIter)115 void TestInsertByte(Mutator M, int NumIter) {
116   FuzzerRandomLibc Rand(0);
117   MutationDispatcher MD(Rand);
118   int FoundMask = 0;
119   uint8_t INS0[8] = {0xF1, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
120   uint8_t INS1[8] = {0x00, 0xF2, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
121   uint8_t INS2[8] = {0x00, 0x11, 0xF3, 0x22, 0x33, 0x44, 0x55, 0x66};
122   uint8_t INS3[8] = {0x00, 0x11, 0x22, 0xF4, 0x33, 0x44, 0x55, 0x66};
123   uint8_t INS4[8] = {0x00, 0x11, 0x22, 0x33, 0xF5, 0x44, 0x55, 0x66};
124   uint8_t INS5[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0xF6, 0x55, 0x66};
125   uint8_t INS6[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xF7, 0x66};
126   uint8_t INS7[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0xF8};
127   for (int i = 0; i < NumIter; i++) {
128     uint8_t T[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
129     size_t NewSize = (MD.*M)(T, 7, 8);
130     if (NewSize == 8 && !memcmp(INS0, T, 8)) FoundMask |= 1 << 0;
131     if (NewSize == 8 && !memcmp(INS1, T, 8)) FoundMask |= 1 << 1;
132     if (NewSize == 8 && !memcmp(INS2, T, 8)) FoundMask |= 1 << 2;
133     if (NewSize == 8 && !memcmp(INS3, T, 8)) FoundMask |= 1 << 3;
134     if (NewSize == 8 && !memcmp(INS4, T, 8)) FoundMask |= 1 << 4;
135     if (NewSize == 8 && !memcmp(INS5, T, 8)) FoundMask |= 1 << 5;
136     if (NewSize == 8 && !memcmp(INS6, T, 8)) FoundMask |= 1 << 6;
137     if (NewSize == 8 && !memcmp(INS7, T, 8)) FoundMask |= 1 << 7;
138   }
139   EXPECT_EQ(FoundMask, 255);
140 }
141 
TEST(FuzzerMutate,InsertByte1)142 TEST(FuzzerMutate, InsertByte1) {
143   TestInsertByte(&MutationDispatcher::Mutate_InsertByte, 1 << 15);
144 }
TEST(FuzzerMutate,InsertByte2)145 TEST(FuzzerMutate, InsertByte2) {
146   TestInsertByte(&MutationDispatcher::Mutate, 1 << 17);
147 }
148 
TestChangeByte(Mutator M,int NumIter)149 void TestChangeByte(Mutator M, int NumIter) {
150   FuzzerRandomLibc Rand(0);
151   MutationDispatcher MD(Rand);
152   int FoundMask = 0;
153   uint8_t CH0[8] = {0xF0, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
154   uint8_t CH1[8] = {0x00, 0xF1, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
155   uint8_t CH2[8] = {0x00, 0x11, 0xF2, 0x33, 0x44, 0x55, 0x66, 0x77};
156   uint8_t CH3[8] = {0x00, 0x11, 0x22, 0xF3, 0x44, 0x55, 0x66, 0x77};
157   uint8_t CH4[8] = {0x00, 0x11, 0x22, 0x33, 0xF4, 0x55, 0x66, 0x77};
158   uint8_t CH5[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0xF5, 0x66, 0x77};
159   uint8_t CH6[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xF5, 0x77};
160   uint8_t CH7[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0xF7};
161   for (int i = 0; i < NumIter; i++) {
162     uint8_t T[9] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
163     size_t NewSize = (MD.*M)(T, 8, 9);
164     if (NewSize == 8 && !memcmp(CH0, T, 8)) FoundMask |= 1 << 0;
165     if (NewSize == 8 && !memcmp(CH1, T, 8)) FoundMask |= 1 << 1;
166     if (NewSize == 8 && !memcmp(CH2, T, 8)) FoundMask |= 1 << 2;
167     if (NewSize == 8 && !memcmp(CH3, T, 8)) FoundMask |= 1 << 3;
168     if (NewSize == 8 && !memcmp(CH4, T, 8)) FoundMask |= 1 << 4;
169     if (NewSize == 8 && !memcmp(CH5, T, 8)) FoundMask |= 1 << 5;
170     if (NewSize == 8 && !memcmp(CH6, T, 8)) FoundMask |= 1 << 6;
171     if (NewSize == 8 && !memcmp(CH7, T, 8)) FoundMask |= 1 << 7;
172   }
173   EXPECT_EQ(FoundMask, 255);
174 }
175 
TEST(FuzzerMutate,ChangeByte1)176 TEST(FuzzerMutate, ChangeByte1) {
177   TestChangeByte(&MutationDispatcher::Mutate_ChangeByte, 1 << 15);
178 }
TEST(FuzzerMutate,ChangeByte2)179 TEST(FuzzerMutate, ChangeByte2) {
180   TestChangeByte(&MutationDispatcher::Mutate, 1 << 17);
181 }
182 
TestChangeBit(Mutator M,int NumIter)183 void TestChangeBit(Mutator M, int NumIter) {
184   FuzzerRandomLibc Rand(0);
185   MutationDispatcher MD(Rand);
186   int FoundMask = 0;
187   uint8_t CH0[8] = {0x01, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
188   uint8_t CH1[8] = {0x00, 0x13, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
189   uint8_t CH2[8] = {0x00, 0x11, 0x02, 0x33, 0x44, 0x55, 0x66, 0x77};
190   uint8_t CH3[8] = {0x00, 0x11, 0x22, 0x37, 0x44, 0x55, 0x66, 0x77};
191   uint8_t CH4[8] = {0x00, 0x11, 0x22, 0x33, 0x54, 0x55, 0x66, 0x77};
192   uint8_t CH5[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x54, 0x66, 0x77};
193   uint8_t CH6[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x76, 0x77};
194   uint8_t CH7[8] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0xF7};
195   for (int i = 0; i < NumIter; i++) {
196     uint8_t T[9] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77};
197     size_t NewSize = (MD.*M)(T, 8, 9);
198     if (NewSize == 8 && !memcmp(CH0, T, 8)) FoundMask |= 1 << 0;
199     if (NewSize == 8 && !memcmp(CH1, T, 8)) FoundMask |= 1 << 1;
200     if (NewSize == 8 && !memcmp(CH2, T, 8)) FoundMask |= 1 << 2;
201     if (NewSize == 8 && !memcmp(CH3, T, 8)) FoundMask |= 1 << 3;
202     if (NewSize == 8 && !memcmp(CH4, T, 8)) FoundMask |= 1 << 4;
203     if (NewSize == 8 && !memcmp(CH5, T, 8)) FoundMask |= 1 << 5;
204     if (NewSize == 8 && !memcmp(CH6, T, 8)) FoundMask |= 1 << 6;
205     if (NewSize == 8 && !memcmp(CH7, T, 8)) FoundMask |= 1 << 7;
206   }
207   EXPECT_EQ(FoundMask, 255);
208 }
209 
TEST(FuzzerMutate,ChangeBit1)210 TEST(FuzzerMutate, ChangeBit1) {
211   TestChangeBit(&MutationDispatcher::Mutate_ChangeBit, 1 << 16);
212 }
TEST(FuzzerMutate,ChangeBit2)213 TEST(FuzzerMutate, ChangeBit2) {
214   TestChangeBit(&MutationDispatcher::Mutate, 1 << 18);
215 }
216 
TestShuffleBytes(Mutator M,int NumIter)217 void TestShuffleBytes(Mutator M, int NumIter) {
218   FuzzerRandomLibc Rand(0);
219   MutationDispatcher MD(Rand);
220   int FoundMask = 0;
221   uint8_t CH0[7] = {0x00, 0x22, 0x11, 0x33, 0x44, 0x55, 0x66};
222   uint8_t CH1[7] = {0x11, 0x00, 0x33, 0x22, 0x44, 0x55, 0x66};
223   uint8_t CH2[7] = {0x00, 0x33, 0x11, 0x22, 0x44, 0x55, 0x66};
224   uint8_t CH3[7] = {0x00, 0x11, 0x22, 0x44, 0x55, 0x66, 0x33};
225   uint8_t CH4[7] = {0x00, 0x11, 0x22, 0x33, 0x55, 0x44, 0x66};
226   for (int i = 0; i < NumIter; i++) {
227     uint8_t T[7] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66};
228     size_t NewSize = (MD.*M)(T, 7, 7);
229     if (NewSize == 7 && !memcmp(CH0, T, 7)) FoundMask |= 1 << 0;
230     if (NewSize == 7 && !memcmp(CH1, T, 7)) FoundMask |= 1 << 1;
231     if (NewSize == 7 && !memcmp(CH2, T, 7)) FoundMask |= 1 << 2;
232     if (NewSize == 7 && !memcmp(CH3, T, 7)) FoundMask |= 1 << 3;
233     if (NewSize == 7 && !memcmp(CH4, T, 7)) FoundMask |= 1 << 4;
234   }
235   EXPECT_EQ(FoundMask, 31);
236 }
237 
TEST(FuzzerMutate,ShuffleBytes1)238 TEST(FuzzerMutate, ShuffleBytes1) {
239   TestShuffleBytes(&MutationDispatcher::Mutate_ShuffleBytes, 1 << 15);
240 }
TEST(FuzzerMutate,ShuffleBytes2)241 TEST(FuzzerMutate, ShuffleBytes2) {
242   TestShuffleBytes(&MutationDispatcher::Mutate, 1 << 19);
243 }
244 
TestAddWordFromDictionary(Mutator M,int NumIter)245 void TestAddWordFromDictionary(Mutator M, int NumIter) {
246   FuzzerRandomLibc Rand(0);
247   MutationDispatcher MD(Rand);
248   uint8_t Word1[4] = {0xAA, 0xBB, 0xCC, 0xDD};
249   uint8_t Word2[3] = {0xFF, 0xEE, 0xEF};
250   MD.AddWordToDictionary(Word1, sizeof(Word1));
251   MD.AddWordToDictionary(Word2, sizeof(Word2));
252   int FoundMask = 0;
253   uint8_t CH0[7] = {0x00, 0x11, 0x22, 0xAA, 0xBB, 0xCC, 0xDD};
254   uint8_t CH1[7] = {0x00, 0x11, 0xAA, 0xBB, 0xCC, 0xDD, 0x22};
255   uint8_t CH2[7] = {0x00, 0xAA, 0xBB, 0xCC, 0xDD, 0x11, 0x22};
256   uint8_t CH3[7] = {0xAA, 0xBB, 0xCC, 0xDD, 0x00, 0x11, 0x22};
257   uint8_t CH4[6] = {0x00, 0x11, 0x22, 0xFF, 0xEE, 0xEF};
258   uint8_t CH5[6] = {0x00, 0x11, 0xFF, 0xEE, 0xEF, 0x22};
259   uint8_t CH6[6] = {0x00, 0xFF, 0xEE, 0xEF, 0x11, 0x22};
260   uint8_t CH7[6] = {0xFF, 0xEE, 0xEF, 0x00, 0x11, 0x22};
261   for (int i = 0; i < NumIter; i++) {
262     uint8_t T[7] = {0x00, 0x11, 0x22};
263     size_t NewSize = (MD.*M)(T, 3, 7);
264     if (NewSize == 7 && !memcmp(CH0, T, 7)) FoundMask |= 1 << 0;
265     if (NewSize == 7 && !memcmp(CH1, T, 7)) FoundMask |= 1 << 1;
266     if (NewSize == 7 && !memcmp(CH2, T, 7)) FoundMask |= 1 << 2;
267     if (NewSize == 7 && !memcmp(CH3, T, 7)) FoundMask |= 1 << 3;
268     if (NewSize == 6 && !memcmp(CH4, T, 6)) FoundMask |= 1 << 4;
269     if (NewSize == 6 && !memcmp(CH5, T, 6)) FoundMask |= 1 << 5;
270     if (NewSize == 6 && !memcmp(CH6, T, 6)) FoundMask |= 1 << 6;
271     if (NewSize == 6 && !memcmp(CH7, T, 6)) FoundMask |= 1 << 7;
272   }
273   EXPECT_EQ(FoundMask, 255);
274 }
275 
TEST(FuzzerMutate,AddWordFromDictionary1)276 TEST(FuzzerMutate, AddWordFromDictionary1) {
277   TestAddWordFromDictionary(&MutationDispatcher::Mutate_AddWordFromDictionary,
278                             1 << 15);
279 }
280 
TEST(FuzzerMutate,AddWordFromDictionary2)281 TEST(FuzzerMutate, AddWordFromDictionary2) {
282   TestAddWordFromDictionary(&MutationDispatcher::Mutate, 1 << 15);
283 }
284 
TestChangeASCIIInteger(Mutator M,int NumIter)285 void TestChangeASCIIInteger(Mutator M, int NumIter) {
286   FuzzerRandomLibc Rand(0);
287   MutationDispatcher MD(Rand);
288 
289   uint8_t CH0[8] = {'1', '2', '3', '4', '5', '6', '7', '7'};
290   uint8_t CH1[8] = {'1', '2', '3', '4', '5', '6', '7', '9'};
291   uint8_t CH2[8] = {'2', '4', '6', '9', '1', '3', '5', '6'};
292   uint8_t CH3[8] = {'0', '6', '1', '7', '2', '8', '3', '9'};
293   int FoundMask = 0;
294   for (int i = 0; i < NumIter; i++) {
295     uint8_t T[8] = {'1', '2', '3', '4', '5', '6', '7', '8'};
296     size_t NewSize = (MD.*M)(T, 8, 8);
297     /**/ if (NewSize == 8 && !memcmp(CH0, T, 8)) FoundMask |= 1 << 0;
298     else if (NewSize == 8 && !memcmp(CH1, T, 8)) FoundMask |= 1 << 1;
299     else if (NewSize == 8 && !memcmp(CH2, T, 8)) FoundMask |= 1 << 2;
300     else if (NewSize == 8 && !memcmp(CH3, T, 8)) FoundMask |= 1 << 3;
301     else if (NewSize == 8)                       FoundMask |= 1 << 4;
302   }
303   EXPECT_EQ(FoundMask, 31);
304 }
305 
TEST(FuzzerMutate,ChangeASCIIInteger1)306 TEST(FuzzerMutate, ChangeASCIIInteger1) {
307   TestChangeASCIIInteger(&MutationDispatcher::Mutate_ChangeASCIIInteger,
308                          1 << 15);
309 }
310 
TEST(FuzzerMutate,ChangeASCIIInteger2)311 TEST(FuzzerMutate, ChangeASCIIInteger2) {
312   TestChangeASCIIInteger(&MutationDispatcher::Mutate, 1 << 15);
313 }
314 
315 
TEST(FuzzerDictionary,ParseOneDictionaryEntry)316 TEST(FuzzerDictionary, ParseOneDictionaryEntry) {
317   Unit U;
318   EXPECT_FALSE(ParseOneDictionaryEntry("", &U));
319   EXPECT_FALSE(ParseOneDictionaryEntry(" ", &U));
320   EXPECT_FALSE(ParseOneDictionaryEntry("\t  ", &U));
321   EXPECT_FALSE(ParseOneDictionaryEntry("  \" ", &U));
322   EXPECT_FALSE(ParseOneDictionaryEntry("  zz\" ", &U));
323   EXPECT_FALSE(ParseOneDictionaryEntry("  \"zz ", &U));
324   EXPECT_FALSE(ParseOneDictionaryEntry("  \"\" ", &U));
325   EXPECT_TRUE(ParseOneDictionaryEntry("\"a\"", &U));
326   EXPECT_EQ(U, Unit({'a'}));
327   EXPECT_TRUE(ParseOneDictionaryEntry("\"abc\"", &U));
328   EXPECT_EQ(U, Unit({'a', 'b', 'c'}));
329   EXPECT_TRUE(ParseOneDictionaryEntry("abc=\"abc\"", &U));
330   EXPECT_EQ(U, Unit({'a', 'b', 'c'}));
331   EXPECT_FALSE(ParseOneDictionaryEntry("\"\\\"", &U));
332   EXPECT_TRUE(ParseOneDictionaryEntry("\"\\\\\"", &U));
333   EXPECT_EQ(U, Unit({'\\'}));
334   EXPECT_TRUE(ParseOneDictionaryEntry("\"\\xAB\"", &U));
335   EXPECT_EQ(U, Unit({0xAB}));
336   EXPECT_TRUE(ParseOneDictionaryEntry("\"\\xABz\\xDE\"", &U));
337   EXPECT_EQ(U, Unit({0xAB, 'z', 0xDE}));
338   EXPECT_TRUE(ParseOneDictionaryEntry("\"#\"", &U));
339   EXPECT_EQ(U, Unit({'#'}));
340   EXPECT_TRUE(ParseOneDictionaryEntry("\"\\\"\"", &U));
341   EXPECT_EQ(U, Unit({'"'}));
342 }
343 
TEST(FuzzerDictionary,ParseDictionaryFile)344 TEST(FuzzerDictionary, ParseDictionaryFile) {
345   std::vector<Unit> Units;
346   EXPECT_FALSE(ParseDictionaryFile("zzz\n", &Units));
347   EXPECT_FALSE(ParseDictionaryFile("", &Units));
348   EXPECT_TRUE(ParseDictionaryFile("\n", &Units));
349   EXPECT_EQ(Units.size(), 0U);
350   EXPECT_TRUE(ParseDictionaryFile("#zzzz a b c d\n", &Units));
351   EXPECT_EQ(Units.size(), 0U);
352   EXPECT_TRUE(ParseDictionaryFile(" #zzzz\n", &Units));
353   EXPECT_EQ(Units.size(), 0U);
354   EXPECT_TRUE(ParseDictionaryFile("  #zzzz\n", &Units));
355   EXPECT_EQ(Units.size(), 0U);
356   EXPECT_TRUE(ParseDictionaryFile("  #zzzz\naaa=\"aa\"", &Units));
357   EXPECT_EQ(Units, std::vector<Unit>({Unit({'a', 'a'})}));
358   EXPECT_TRUE(
359       ParseDictionaryFile("  #zzzz\naaa=\"aa\"\n\nabc=\"abc\"", &Units));
360   EXPECT_EQ(Units,
361             std::vector<Unit>({Unit({'a', 'a'}), Unit({'a', 'b', 'c'})}));
362 }
363 
TEST(FuzzerUtil,Base64)364 TEST(FuzzerUtil, Base64) {
365   EXPECT_EQ("", Base64({}));
366   EXPECT_EQ("YQ==", Base64({'a'}));
367   EXPECT_EQ("eA==", Base64({'x'}));
368   EXPECT_EQ("YWI=", Base64({'a', 'b'}));
369   EXPECT_EQ("eHk=", Base64({'x', 'y'}));
370   EXPECT_EQ("YWJj", Base64({'a', 'b', 'c'}));
371   EXPECT_EQ("eHl6", Base64({'x', 'y', 'z'}));
372   EXPECT_EQ("YWJjeA==", Base64({'a', 'b', 'c', 'x'}));
373   EXPECT_EQ("YWJjeHk=", Base64({'a', 'b', 'c', 'x', 'y'}));
374   EXPECT_EQ("YWJjeHl6", Base64({'a', 'b', 'c', 'x', 'y', 'z'}));
375 }
376