1// Copyright 2018 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <stdint.h>
6
7#include <unittest/unittest.h>
8
9#include "fuzzer-fixture.h"
10#include "test-fuzzer.h"
11
12namespace fuzzing {
13namespace testing {
14namespace {
15
16// See fuzzer-fixture.cpp for the location and contents of test files.
17
18bool TestSetOption() {
19    BEGIN_TEST;
20    TestFuzzer test;
21    ASSERT_TRUE(test.InitZircon());
22
23    EXPECT_NE(ZX_OK, test.SetOption("", "value1"));
24    EXPECT_NE(ZX_OK, test.SetOption("key1", ""));
25
26    // Value isn't set
27    const char* value = test.GetOption("key1");
28    EXPECT_NULL(value);
29
30    // Empty options are ignored
31    EXPECT_EQ(ZX_OK, test.SetOption("", ""));
32    EXPECT_EQ(ZX_OK, test.SetOption(""));
33    EXPECT_EQ(ZX_OK, test.SetOption("# A comment"));
34    EXPECT_EQ(ZX_OK, test.SetOption("   # A comment with leading whitespace"));
35
36    // Set some values normally
37    EXPECT_EQ(ZX_OK, test.SetOption("key1", "value1"));
38    EXPECT_EQ(ZX_OK, test.SetOption("key2", "value2"));
39    EXPECT_EQ(ZX_OK, test.SetOption("key3=value3"));
40    EXPECT_EQ(ZX_OK, test.SetOption("\t -key4 \t=\t value4 \t# A comment"));
41
42    // Check values
43    value = test.GetOption("key1");
44    ASSERT_NONNULL(value);
45    EXPECT_STR_EQ(value, "value1");
46
47    value = test.GetOption("key2");
48    ASSERT_NONNULL(value);
49    EXPECT_STR_EQ(value, "value2");
50
51    value = test.GetOption("key3");
52    ASSERT_NONNULL(value);
53    EXPECT_STR_EQ(value, "value3");
54
55    value = test.GetOption("key4");
56    ASSERT_NONNULL(value);
57    EXPECT_STR_EQ(value, "value4");
58
59    // Replace each option
60    EXPECT_EQ(ZX_OK, test.SetOption("key3", "value4"));
61    EXPECT_EQ(ZX_OK, test.SetOption("key2=value3"));
62    EXPECT_EQ(ZX_OK, test.SetOption(" \t-key1\t = \tvalue2\t # A comment"));
63    EXPECT_EQ(ZX_OK, test.SetOption("key4", "value1"));
64
65    // Check values
66    value = test.GetOption("key1");
67    ASSERT_NONNULL(value);
68    EXPECT_STR_EQ(value, "value2");
69
70    value = test.GetOption("key2");
71    ASSERT_NONNULL(value);
72    EXPECT_STR_EQ(value, "value3");
73
74    value = test.GetOption("key3");
75    ASSERT_NONNULL(value);
76    EXPECT_STR_EQ(value, "value4");
77
78    value = test.GetOption("key4");
79    ASSERT_NONNULL(value);
80    EXPECT_STR_EQ(value, "value1");
81
82    // Must be key value pair
83    EXPECT_NE(ZX_OK, test.SetOption("key1", ""));
84    EXPECT_NE(ZX_OK, test.SetOption("", "value2"));
85    EXPECT_NE(ZX_OK, test.SetOption("key3"));
86    EXPECT_NE(ZX_OK, test.SetOption("key5=#value5"));
87
88    END_TEST;
89}
90
91bool TestRebasePath() {
92    BEGIN_TEST;
93    TestFuzzer test;
94    ASSERT_TRUE(test.InitZircon());
95    const FuzzerFixture& fixture = test.fixture();
96
97    Path path;
98    EXPECT_EQ(ZX_OK, test.RebasePath("boot", &path));
99    EXPECT_STR_EQ(path.c_str(), fixture.path("boot/").c_str());
100
101    EXPECT_EQ(ZX_OK, test.RebasePath("boot/test/fuzz", &path));
102    EXPECT_STR_EQ(path.c_str(), fixture.path("boot/test/fuzz/").c_str());
103
104    EXPECT_NE(ZX_OK, test.RebasePath("pkgfs", &path));
105    EXPECT_STR_EQ(path.c_str(), fixture.path().c_str());
106
107    END_TEST;
108}
109
110bool TestGetPackagePath() {
111    BEGIN_TEST;
112    TestFuzzer test;
113    ASSERT_TRUE(test.InitFuchsia());
114    const FuzzerFixture& fixture = test.fixture();
115
116    Path path;
117    fbl::String expected;
118    EXPECT_NE(ZX_OK, test.GetPackagePath("", &path));
119    EXPECT_STR_EQ(path.c_str(), fixture.path().c_str());
120
121    EXPECT_NE(ZX_OK, test.GetPackagePath("not-a-package", &path));
122    EXPECT_STR_EQ(path.c_str(), fixture.path().c_str());
123
124    const char* package = "zircon_fuzzers";
125    EXPECT_EQ(ZX_OK, test.GetPackagePath(package, &path));
126    EXPECT_STR_EQ(
127        path.c_str(),
128        fixture.path("pkgfs/packages/%s/%s/", package, fixture.max_version(package)).c_str());
129
130    EXPECT_NE(ZX_OK, test.GetPackagePath("fuchsia", &path));
131    EXPECT_STR_EQ(path.c_str(), fixture.path().c_str());
132
133    package = "fuchsia1_fuzzers";
134    EXPECT_EQ(ZX_OK, test.GetPackagePath(package, &path));
135    EXPECT_STR_EQ(
136        path.c_str(),
137        fixture.path("pkgfs/packages/%s/%s/", package, fixture.max_version(package)).c_str());
138
139    package = "fuchsia2_fuzzers";
140    EXPECT_EQ(ZX_OK, test.GetPackagePath(package, &path));
141    EXPECT_STR_EQ(
142        path.c_str(),
143        fixture.path("pkgfs/packages/%s/%s/", package, fixture.max_version(package)).c_str());
144
145    END_TEST;
146}
147
148bool TestFindZirconFuzzers() {
149    BEGIN_TEST;
150    TestFuzzer test;
151    ASSERT_TRUE(test.InitZircon());
152
153    StringMap fuzzers;
154    test.FindZirconFuzzers("no/such/dir", "", &fuzzers);
155    EXPECT_EQ(fuzzers.size(), 0);
156
157    test.FindZirconFuzzers("boot/test/fuzz", "no-such", &fuzzers);
158    EXPECT_EQ(fuzzers.size(), 0);
159
160    // Empty matches all
161    test.FindZirconFuzzers("boot/test/fuzz", "", &fuzzers);
162    EXPECT_EQ(fuzzers.size(), 2);
163    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
164    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
165
166    // Idempotent
167    test.FindZirconFuzzers("boot/test/fuzz", "", &fuzzers);
168    EXPECT_EQ(fuzzers.size(), 2);
169    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
170    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
171
172    // Substrings match
173    fuzzers.clear();
174    test.FindZirconFuzzers("boot/test/fuzz", "target", &fuzzers);
175    EXPECT_EQ(fuzzers.size(), 2);
176    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
177    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
178
179    fuzzers.clear();
180    test.FindZirconFuzzers("boot/test/fuzz", "1", &fuzzers);
181    EXPECT_EQ(fuzzers.size(), 1);
182    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
183    EXPECT_NULL(fuzzers.get("zircon_fuzzers/target2"));
184
185    END_TEST;
186}
187
188bool TestFindFuchsiaFuzzers() {
189    BEGIN_TEST;
190    TestFuzzer test;
191    ASSERT_TRUE(test.InitFuchsia());
192
193    StringMap fuzzers;
194    test.FindFuchsiaFuzzers("not-a-package", "", &fuzzers);
195    EXPECT_EQ(fuzzers.size(), 0);
196
197    test.FindFuchsiaFuzzers("", "not-a-target", &fuzzers);
198    EXPECT_EQ(fuzzers.size(), 0);
199
200    // Empty matches all
201    test.FindFuchsiaFuzzers("", "", &fuzzers);
202    EXPECT_EQ(fuzzers.size(), 5);
203    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
204    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
205    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
206    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
207    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
208
209    // Idempotent
210    test.FindFuchsiaFuzzers("", "", &fuzzers);
211    EXPECT_EQ(fuzzers.size(), 5);
212    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
213    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
214    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
215    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
216    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
217
218    // Substrings match
219    fuzzers.clear();
220    test.FindFuchsiaFuzzers("fuchsia", "", &fuzzers);
221    EXPECT_EQ(fuzzers.size(), 4);
222    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
223    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
224    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
225    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
226
227    fuzzers.clear();
228    test.FindFuchsiaFuzzers("", "target", &fuzzers);
229    EXPECT_EQ(fuzzers.size(), 5);
230    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
231    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
232    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
233    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
234    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
235
236    fuzzers.clear();
237    test.FindFuchsiaFuzzers("fuchsia", "target", &fuzzers);
238    EXPECT_EQ(fuzzers.size(), 4);
239    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
240    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
241    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
242    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
243
244    fuzzers.clear();
245    test.FindFuchsiaFuzzers("", "1", &fuzzers);
246    EXPECT_EQ(fuzzers.size(), 1);
247    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
248
249    fuzzers.clear();
250    test.FindFuchsiaFuzzers("1", "", &fuzzers);
251    EXPECT_EQ(fuzzers.size(), 3);
252    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
253    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
254    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
255
256    fuzzers.clear();
257    test.FindFuchsiaFuzzers("1", "4", &fuzzers);
258    EXPECT_EQ(fuzzers.size(), 0);
259
260    fuzzers.clear();
261    test.FindFuchsiaFuzzers("2", "1", &fuzzers);
262    EXPECT_EQ(fuzzers.size(), 0);
263
264    END_TEST;
265}
266
267bool TestFindFuzzers() {
268    BEGIN_TEST;
269
270    // Zircon tests
271    TestFuzzer test;
272    ASSERT_TRUE(test.InitZircon());
273
274    // Empty matches all
275    StringMap fuzzers;
276    test.FindFuzzers("", &fuzzers);
277    EXPECT_EQ(fuzzers.size(), 2);
278    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
279    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
280
281    // Idempotent
282    test.FindFuzzers("", &fuzzers);
283    EXPECT_EQ(fuzzers.size(), 2);
284    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
285    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
286
287    // Substrings match
288    fuzzers.clear();
289    test.FindFuzzers("invalid", &fuzzers);
290    EXPECT_EQ(fuzzers.size(), 0);
291
292    test.FindFuzzers("fuchsia", &fuzzers);
293    EXPECT_EQ(fuzzers.size(), 0);
294
295    fuzzers.clear();
296    test.FindFuzzers("zircon", &fuzzers);
297    EXPECT_EQ(fuzzers.size(), 2);
298    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
299    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
300    EXPECT_NULL(fuzzers.get("fuchsia1_fuzzers/target1"));
301    EXPECT_NULL(fuzzers.get("fuchsia1_fuzzers/target2"));
302    EXPECT_NULL(fuzzers.get("fuchsia1_fuzzers/target3"));
303    EXPECT_NULL(fuzzers.get("fuchsia2_fuzzers/target4"));
304
305    fuzzers.clear();
306    test.FindFuzzers("target", &fuzzers);
307    EXPECT_EQ(fuzzers.size(), 2);
308    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
309    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
310
311    fuzzers.clear();
312    test.FindFuzzers("1", &fuzzers);
313    EXPECT_EQ(fuzzers.size(), 1);
314    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
315
316    // Fuchsia tests
317    ASSERT_TRUE(test.InitFuchsia());
318
319    // Empty matches all
320    test.FindFuzzers("", &fuzzers);
321    EXPECT_EQ(fuzzers.size(), 6);
322    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
323    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
324    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
325    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
326    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
327    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
328
329    // Idempotent
330    test.FindFuzzers("", &fuzzers);
331    EXPECT_EQ(fuzzers.size(), 6);
332    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
333    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
334    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
335    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
336    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
337    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
338
339    // Substrings match
340    fuzzers.clear();
341    test.FindFuzzers("fuzzers/no-such-target", &fuzzers);
342    EXPECT_EQ(fuzzers.size(), 0);
343
344    test.FindFuzzers("no-such-package/target", &fuzzers);
345    EXPECT_EQ(fuzzers.size(), 0);
346
347    test.FindFuzzers("zircon", &fuzzers);
348    EXPECT_EQ(fuzzers.size(), 2);
349    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
350    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
351
352    fuzzers.clear();
353    test.FindFuzzers("fuchsia", &fuzzers);
354    EXPECT_EQ(fuzzers.size(), 4);
355    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
356    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
357    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
358    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
359
360    fuzzers.clear();
361    test.FindFuzzers("fuchsia2", &fuzzers);
362    EXPECT_EQ(fuzzers.size(), 1);
363    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
364
365    fuzzers.clear();
366    test.FindFuzzers("fuchsia", &fuzzers);
367    EXPECT_EQ(fuzzers.size(), 4);
368    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
369    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
370    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
371    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
372
373    fuzzers.clear();
374    test.FindFuzzers("_fuzzers/target", &fuzzers);
375    EXPECT_EQ(fuzzers.size(), 6);
376    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
377    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target2"));
378    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
379    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
380    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
381    EXPECT_NONNULL(fuzzers.get("fuchsia2_fuzzers/target4"));
382
383    fuzzers.clear();
384    test.FindFuzzers("1", &fuzzers);
385    EXPECT_EQ(fuzzers.size(), 4);
386    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
387    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
388    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
389    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
390
391    fuzzers.clear();
392    test.FindFuzzers("1/", &fuzzers);
393    EXPECT_EQ(fuzzers.size(), 3);
394    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
395    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target2"));
396    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target3"));
397
398    fuzzers.clear();
399    test.FindFuzzers("/1", &fuzzers);
400    EXPECT_EQ(fuzzers.size(), 2);
401    EXPECT_NONNULL(fuzzers.get("zircon_fuzzers/target1"));
402    EXPECT_NONNULL(fuzzers.get("fuchsia1_fuzzers/target1"));
403
404    END_TEST;
405}
406
407bool TestCheckProcess() {
408    BEGIN_TEST;
409    TestFuzzer test;
410    ASSERT_TRUE(test.InitZircon());
411
412    EXPECT_FALSE(test.CheckProcess(ZX_HANDLE_INVALID));
413    EXPECT_FALSE(test.CheckProcess(zx_process_self()));
414
415    char name[ZX_MAX_NAME_LEN];
416    ASSERT_EQ(ZX_OK, zx_object_get_property(zx_process_self(), ZX_PROP_NAME, name, sizeof(name)));
417
418    EXPECT_TRUE(test.CheckProcess(zx_process_self(), name));
419
420    END_TEST;
421}
422
423bool TestInvalid() {
424    BEGIN_TEST;
425    TestFuzzer test;
426    ASSERT_TRUE(test.InitZircon());
427
428    ASSERT_TRUE(test.Eval(""));
429    EXPECT_NE(ZX_OK, test.Run());
430    ASSERT_TRUE(test.Eval("bad"));
431    EXPECT_NE(ZX_OK, test.Run());
432
433    END_TEST;
434}
435
436bool TestHelp() {
437    BEGIN_TEST;
438    TestFuzzer test;
439    ASSERT_TRUE(test.InitZircon());
440
441    ASSERT_TRUE(test.Eval("help"));
442    EXPECT_EQ(ZX_OK, test.Run());
443    EXPECT_TRUE(test.InStdOut("help"));
444    EXPECT_TRUE(test.InStdOut("list"));
445    EXPECT_TRUE(test.InStdOut("seeds"));
446    EXPECT_TRUE(test.InStdOut("start"));
447    EXPECT_TRUE(test.InStdOut("check"));
448    EXPECT_TRUE(test.InStdOut("stop"));
449    EXPECT_TRUE(test.InStdOut("repro"));
450    EXPECT_TRUE(test.InStdOut("merge"));
451
452    END_TEST;
453}
454
455bool TestList() {
456    BEGIN_TEST;
457    TestFuzzer test;
458
459    // Zircon tests
460    ASSERT_TRUE(test.InitZircon());
461
462    ASSERT_TRUE(test.Eval("list"));
463    EXPECT_EQ(ZX_OK, test.Run());
464    EXPECT_TRUE(test.InStdOut("zircon_fuzzers/target1"));
465    EXPECT_TRUE(test.InStdOut("zircon_fuzzers/target2"));
466    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target1"));
467    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target2"));
468    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target3"));
469    EXPECT_FALSE(test.InStdOut("fuchsia2_fuzzers/target4"));
470
471    ASSERT_TRUE(test.Eval("list fuchsia"));
472    EXPECT_EQ(ZX_OK, test.Run());
473    EXPECT_TRUE(test.InStdOut("no match"));
474
475    ASSERT_TRUE(test.Eval("list target"));
476    EXPECT_EQ(ZX_OK, test.Run());
477    EXPECT_TRUE(test.InStdOut("zircon_fuzzers/target1"));
478    EXPECT_TRUE(test.InStdOut("zircon_fuzzers/target2"));
479    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target1"));
480    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target2"));
481    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target3"));
482    EXPECT_FALSE(test.InStdOut("fuchsia2_fuzzers/target4"));
483
484    ASSERT_TRUE(test.Eval("list zircon_fuzzers/target1"));
485    EXPECT_EQ(ZX_OK, test.Run());
486    EXPECT_TRUE(test.InStdOut("zircon_fuzzers/target1"));
487    EXPECT_FALSE(test.InStdOut("zircon_fuzzers/target2"));
488    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target1"));
489    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target2"));
490    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target3"));
491    EXPECT_FALSE(test.InStdOut("fuchsia2_fuzzers/target4"));
492
493    // Fuchsia tests
494    ASSERT_TRUE(test.InitFuchsia());
495
496    ASSERT_TRUE(test.Eval("list"));
497    EXPECT_EQ(ZX_OK, test.Run());
498    EXPECT_TRUE(test.InStdOut("zircon_fuzzers/target1"));
499    EXPECT_TRUE(test.InStdOut("zircon_fuzzers/target2"));
500    EXPECT_TRUE(test.InStdOut("fuchsia1_fuzzers/target1"));
501    EXPECT_TRUE(test.InStdOut("fuchsia1_fuzzers/target2"));
502    EXPECT_TRUE(test.InStdOut("fuchsia1_fuzzers/target3"));
503    EXPECT_TRUE(test.InStdOut("fuchsia2_fuzzers/target4"));
504
505    ASSERT_TRUE(test.Eval("list fuchsia"));
506    EXPECT_EQ(ZX_OK, test.Run());
507    EXPECT_FALSE(test.InStdOut("zircon_fuzzers/target1"));
508    EXPECT_FALSE(test.InStdOut("zircon_fuzzers/target2"));
509    EXPECT_TRUE(test.InStdOut("fuchsia1_fuzzers/target1"));
510    EXPECT_TRUE(test.InStdOut("fuchsia1_fuzzers/target2"));
511    EXPECT_TRUE(test.InStdOut("fuchsia1_fuzzers/target3"));
512    EXPECT_TRUE(test.InStdOut("fuchsia2_fuzzers/target4"));
513
514    ASSERT_TRUE(test.Eval("list target"));
515    EXPECT_EQ(ZX_OK, test.Run());
516    EXPECT_TRUE(test.InStdOut("zircon_fuzzers/target1"));
517    EXPECT_TRUE(test.InStdOut("zircon_fuzzers/target2"));
518    EXPECT_TRUE(test.InStdOut("fuchsia1_fuzzers/target1"));
519    EXPECT_TRUE(test.InStdOut("fuchsia1_fuzzers/target2"));
520    EXPECT_TRUE(test.InStdOut("fuchsia1_fuzzers/target3"));
521    EXPECT_TRUE(test.InStdOut("fuchsia2_fuzzers/target4"));
522
523    ASSERT_TRUE(test.Eval("list fuchsia1_fuzzers/target1"));
524    EXPECT_EQ(ZX_OK, test.Run());
525    EXPECT_FALSE(test.InStdOut("zircon_fuzzers/target1"));
526    EXPECT_FALSE(test.InStdOut("zircon_fuzzers/target2"));
527    EXPECT_TRUE(test.InStdOut("fuchsia1_fuzzers/target1"));
528    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target2"));
529    EXPECT_FALSE(test.InStdOut("fuchsia1_fuzzers/target3"));
530    EXPECT_FALSE(test.InStdOut("fuchsia2_fuzzers/target4"));
531
532    END_TEST;
533}
534
535bool TestSeeds() {
536    BEGIN_TEST;
537    TestFuzzer test;
538
539    // Zircon tests
540    ASSERT_TRUE(test.InitZircon());
541
542    ASSERT_TRUE(test.Eval("seeds"));
543    EXPECT_NE(ZX_OK, test.Run());
544    EXPECT_TRUE(test.InStdErr("missing"));
545
546    ASSERT_TRUE(test.Eval("seeds foobar"));
547    EXPECT_NE(ZX_OK, test.Run());
548    EXPECT_TRUE(test.InStdErr("no match"));
549
550    ASSERT_TRUE(test.Eval("seeds target"));
551    EXPECT_NE(ZX_OK, test.Run());
552    EXPECT_TRUE(test.InStdErr("multiple"));
553
554    ASSERT_TRUE(test.Eval("seeds zircon/target2"));
555    EXPECT_EQ(ZX_OK, test.Run());
556    EXPECT_TRUE(test.InStdOut("no seed"));
557
558    // Fuchsia tests
559    ASSERT_TRUE(test.InitFuchsia());
560
561    ASSERT_TRUE(test.Eval("seeds zircon/target2"));
562    EXPECT_EQ(ZX_OK, test.Run());
563    EXPECT_TRUE(test.InStdOut("//path/to/seed/corpus"));
564    EXPECT_TRUE(test.InStdOut("//path/to/cipd/ensure/file"));
565    EXPECT_TRUE(test.InStdOut("https://gcs/url"));
566
567    ASSERT_TRUE(test.Eval("seeds fuchsia1/target3"));
568    EXPECT_EQ(ZX_OK, test.Run());
569    EXPECT_TRUE(test.InStdOut("//path/to/seed/corpus"));
570    EXPECT_TRUE(test.InStdOut("//path/to/cipd/ensure/file"));
571    EXPECT_TRUE(test.InStdOut("https://gcs/url"));
572
573    END_TEST;
574}
575
576bool TestStart() {
577    BEGIN_TEST;
578    TestFuzzer test;
579
580    // Zircon tests
581    ASSERT_TRUE(test.InitZircon());
582
583    ASSERT_TRUE(test.Eval("start"));
584    EXPECT_NE(ZX_OK, test.Run());
585    EXPECT_TRUE(test.InStdErr("missing"));
586
587    ASSERT_TRUE(test.Eval("start foobar"));
588    EXPECT_NE(ZX_OK, test.Run());
589    EXPECT_TRUE(test.InStdErr("no match"));
590
591    ASSERT_TRUE(test.Eval("start target"));
592    EXPECT_NE(ZX_OK, test.Run());
593    EXPECT_TRUE(test.InStdErr("multiple"));
594
595    // Zircon fuzzer
596    ASSERT_TRUE(test.Eval("start zircon/target2"));
597    EXPECT_EQ(ZX_OK, test.Run());
598    EXPECT_EQ(0, test.FindArg(test.executable()));
599    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
600    EXPECT_LT(0, test.FindArg(test.data_path("corpus").c_str()));
601
602    // // // Fuchsia tests
603    ASSERT_TRUE(test.InitFuchsia());
604
605    // Zircon fuzzer within Fuchsia
606    ASSERT_TRUE(test.Eval("start zircon/target2"));
607    EXPECT_EQ(ZX_OK, test.Run());
608    EXPECT_EQ(0, test.FindArg(test.executable()));
609    EXPECT_LT(0, test.FindArg(test.manifest()));
610    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
611    EXPECT_LT(0, test.FindArg("-baz=qux"));
612    EXPECT_LT(0, test.FindArg("-dict=%s", test.dictionary()));
613    EXPECT_LT(0, test.FindArg("-foo=bar"));
614    EXPECT_LT(0, test.FindArg(test.data_path("corpus").c_str()));
615
616    // Fuchsia fuzzer without resources
617    ASSERT_TRUE(test.Eval("start fuchsia1/target1"));
618    EXPECT_EQ(ZX_OK, test.Run());
619    EXPECT_EQ(0, test.FindArg(test.executable()));
620    EXPECT_LT(0, test.FindArg(test.manifest()));
621    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
622
623    // Fuchsia fuzzer with resources
624    ASSERT_TRUE(test.Eval("start fuchsia1/target3"));
625    EXPECT_EQ(ZX_OK, test.Run());
626    EXPECT_EQ(0, test.FindArg(test.executable()));
627    EXPECT_LT(0, test.FindArg(test.manifest()));
628    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
629    EXPECT_LT(0, test.FindArg("-baz=qux"));
630    EXPECT_LT(0, test.FindArg("-dict=%s", test.dictionary()));
631    EXPECT_LT(0, test.FindArg("-foo=bar"));
632    EXPECT_LT(0, test.FindArg(test.data_path("corpus").c_str()));
633
634    // Fuchsia fuzzer with resources, command-line option, and explicit corpus
635    ASSERT_TRUE(test.Eval("start fuchsia2/target4 /path/to/another/corpus -foo=baz"));
636    EXPECT_EQ(ZX_OK, test.Run());
637    EXPECT_EQ(0, test.FindArg(test.executable()));
638    EXPECT_LT(0, test.FindArg(test.manifest()));
639    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
640    EXPECT_LT(0, test.FindArg("-baz=qux"));
641    EXPECT_LT(0, test.FindArg("-dict=%s", test.dictionary()));
642    EXPECT_LT(0, test.FindArg("-foo=baz"));
643    EXPECT_LT(0, test.FindArg("/path/to/another/corpus"));
644    EXPECT_GT(0, test.FindArg(test.data_path("corpus").c_str()));
645
646    END_TEST;
647}
648
649bool TestCheck() {
650    BEGIN_TEST;
651    TestFuzzer test;
652
653    // Zircon tests
654    ASSERT_TRUE(test.InitZircon());
655
656    ASSERT_TRUE(test.Eval("check"));
657    EXPECT_NE(ZX_OK, test.Run());
658    EXPECT_TRUE(test.InStdErr("missing"));
659
660    ASSERT_TRUE(test.Eval("check foobar"));
661    EXPECT_NE(ZX_OK, test.Run());
662    EXPECT_TRUE(test.InStdErr("no match"));
663
664    ASSERT_TRUE(test.Eval("check target"));
665    EXPECT_NE(ZX_OK, test.Run());
666    EXPECT_TRUE(test.InStdErr("multiple"));
667
668    ASSERT_TRUE(test.Eval("check zircon/target1"));
669    EXPECT_EQ(ZX_OK, test.Run());
670    EXPECT_TRUE(test.InStdOut("stopped"));
671    EXPECT_TRUE(test.InStdOut(test.executable()));
672    EXPECT_TRUE(test.InStdOut(test.data_path()));
673    EXPECT_TRUE(test.InStdOut("0 inputs"));
674    EXPECT_TRUE(test.InStdOut("none"));
675
676    ASSERT_TRUE(test.Eval("check zircon/target2"));
677    EXPECT_EQ(ZX_OK, test.Run());
678    EXPECT_TRUE(test.InStdOut("stopped"));
679    EXPECT_TRUE(test.InStdOut(test.executable()));
680    EXPECT_TRUE(test.InStdOut(test.data_path()));
681    EXPECT_TRUE(test.InStdOut("0 inputs"));
682    EXPECT_TRUE(test.InStdOut("crash"));
683
684    // Fuchsia tests
685    ASSERT_TRUE(test.InitFuchsia());
686
687    ASSERT_TRUE(test.Eval("check zircon/target2"));
688    EXPECT_EQ(ZX_OK, test.Run());
689    EXPECT_TRUE(test.InStdOut("stopped"));
690    EXPECT_TRUE(test.InStdOut(test.executable()));
691    EXPECT_TRUE(test.InStdOut(test.data_path()));
692    EXPECT_TRUE(test.InStdOut("0 inputs"));
693    EXPECT_TRUE(test.InStdOut("crash"));
694
695    ASSERT_TRUE(test.Eval("check fuchsia/target1"));
696    EXPECT_EQ(ZX_OK, test.Run());
697    EXPECT_TRUE(test.InStdOut("stopped"));
698    EXPECT_TRUE(test.InStdOut(test.executable()));
699    EXPECT_TRUE(test.InStdOut(test.data_path()));
700    EXPECT_TRUE(test.InStdOut("0 inputs"));
701    EXPECT_TRUE(test.InStdOut("none"));
702
703    ASSERT_TRUE(test.Eval("check fuchsia/target4"));
704    EXPECT_EQ(ZX_OK, test.Run());
705    EXPECT_TRUE(test.InStdOut("stopped"));
706    EXPECT_TRUE(test.InStdOut(test.executable()));
707    EXPECT_TRUE(test.InStdOut(test.data_path()));
708    EXPECT_TRUE(test.InStdOut("0 inputs"));
709    EXPECT_TRUE(test.InStdOut("crash"));
710
711    END_TEST;
712}
713
714bool TestStop() {
715    BEGIN_TEST;
716    TestFuzzer test;
717
718    ASSERT_TRUE(test.InitZircon());
719
720    ASSERT_TRUE(test.Eval("stop"));
721    EXPECT_NE(ZX_OK, test.Run());
722    EXPECT_TRUE(test.InStdErr("missing"));
723
724    ASSERT_TRUE(test.Eval("stop foobar"));
725    EXPECT_NE(ZX_OK, test.Run());
726    EXPECT_TRUE(test.InStdErr("no match"));
727
728    ASSERT_TRUE(test.Eval("stop target"));
729    EXPECT_NE(ZX_OK, test.Run());
730    EXPECT_TRUE(test.InStdErr("multiple"));
731
732    ASSERT_TRUE(test.Eval("stop zircon/target1"));
733    EXPECT_EQ(ZX_OK, test.Run());
734    EXPECT_TRUE(test.InStdOut("stopped"));
735
736    END_TEST;
737}
738
739bool TestRepro() {
740    BEGIN_TEST;
741    TestFuzzer test;
742
743    // Zircon tests
744    FuzzerFixture fixture;
745    ASSERT_TRUE(test.InitZircon());
746
747    ASSERT_TRUE(test.Eval("repro"));
748    EXPECT_NE(ZX_OK, test.Run());
749    EXPECT_TRUE(test.InStdErr("missing"));
750
751    ASSERT_TRUE(test.Eval("repro foobar"));
752    EXPECT_NE(ZX_OK, test.Run());
753    EXPECT_TRUE(test.InStdErr("no match"));
754
755    ASSERT_TRUE(test.Eval("repro target"));
756    EXPECT_NE(ZX_OK, test.Run());
757    EXPECT_TRUE(test.InStdErr("multiple"));
758
759    ASSERT_TRUE(test.Eval("repro zircon/target1"));
760    EXPECT_NE(ZX_OK, test.Run());
761    EXPECT_TRUE(test.InStdErr("no match"));
762
763    // Automatically add artifacts
764    ASSERT_TRUE(test.Eval("repro zircon/target2"));
765    EXPECT_EQ(ZX_OK, test.Run());
766    EXPECT_EQ(0, test.FindArg(test.executable()));
767    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
768    EXPECT_LT(0, test.FindArg(test.data_path("crash-deadbeef").c_str()));
769    EXPECT_LT(0, test.FindArg(test.data_path("leak-deadfa11").c_str()));
770    EXPECT_LT(0, test.FindArg(test.data_path("oom-feedface").c_str()));
771
772    // Filter artifacts based on substring
773    ASSERT_TRUE(test.Eval("repro zircon/target2 dead"));
774    EXPECT_EQ(ZX_OK, test.Run());
775    EXPECT_EQ(0, test.FindArg(test.executable()));
776    EXPECT_LT(0, test.FindArg(test.data_path("crash-deadbeef").c_str()));
777    EXPECT_LT(0, test.FindArg(test.data_path("leak-deadfa11").c_str()));
778    EXPECT_GT(0, test.FindArg(test.data_path("oom-feedface").c_str()));
779
780    // Fuchsia tests
781    ASSERT_TRUE(test.InitFuchsia());
782
783    // Zircon fuzzer within Fuchsia
784    ASSERT_TRUE(test.Eval("repro zircon/target2 fa"));
785    EXPECT_EQ(ZX_OK, test.Run());
786    EXPECT_EQ(0, test.FindArg(test.executable()));
787    EXPECT_LT(0, test.FindArg(test.manifest()));
788    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
789    EXPECT_LT(0, test.FindArg("-baz=qux"));
790    EXPECT_LT(0, test.FindArg("-dict=%s", test.dictionary()));
791    EXPECT_LT(0, test.FindArg("-foo=bar"));
792    EXPECT_LT(0, test.FindArg(test.data_path("leak-deadfa11").c_str()));
793    EXPECT_LT(0, test.FindArg(test.data_path("oom-feedface").c_str()));
794    EXPECT_GT(0, test.FindArg(test.data_path("crash-deadbeef").c_str()));
795    EXPECT_GT(0, test.FindArg(test.data_path("corpus").c_str()));
796
797    ASSERT_TRUE(test.Eval("repro fuchsia1/target1"));
798    EXPECT_NE(ZX_OK, test.Run());
799    EXPECT_TRUE(test.InStdErr("no match"));
800
801    // Fuchsia fuzzer with resources
802    ASSERT_TRUE(test.Eval("repro fuchsia2/target4"));
803    EXPECT_EQ(ZX_OK, test.Run());
804    EXPECT_EQ(0, test.FindArg(test.executable()));
805    EXPECT_LT(0, test.FindArg(test.manifest()));
806    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
807    EXPECT_LT(0, test.FindArg("-baz=qux"));
808    EXPECT_LT(0, test.FindArg("-dict=%s", test.dictionary()));
809    EXPECT_LT(0, test.FindArg("-foo=bar"));
810    EXPECT_LT(0, test.FindArg(test.data_path("leak-deadfa11").c_str()));
811    EXPECT_LT(0, test.FindArg(test.data_path("oom-feedface").c_str()));
812    EXPECT_LT(0, test.FindArg(test.data_path("crash-deadbeef").c_str()));
813    EXPECT_GT(0, test.FindArg(test.data_path("corpus").c_str()));
814
815    END_TEST;
816}
817
818bool TestMerge() {
819    BEGIN_TEST;
820    TestFuzzer test;
821
822    // Zircon tests
823    FuzzerFixture fixture;
824    ASSERT_TRUE(test.InitZircon());
825
826    ASSERT_TRUE(test.Eval("merge"));
827    EXPECT_NE(ZX_OK, test.Run());
828    EXPECT_TRUE(test.InStdErr("missing"));
829
830    ASSERT_TRUE(test.Eval("merge foobar"));
831    EXPECT_NE(ZX_OK, test.Run());
832    EXPECT_TRUE(test.InStdErr("no match"));
833
834    ASSERT_TRUE(test.Eval("merge target"));
835    EXPECT_NE(ZX_OK, test.Run());
836    EXPECT_TRUE(test.InStdErr("multiple"));
837
838    // Can't merge if no corpus
839    ASSERT_TRUE(test.Eval("merge zircon/target1"));
840    EXPECT_NE(ZX_OK, test.Run());
841    EXPECT_TRUE(test.InStdErr("failed"));
842
843    // Zircon minimizing merge
844    ASSERT_TRUE(test.Eval("merge zircon/target2"));
845    EXPECT_EQ(ZX_OK, test.Run());
846    EXPECT_EQ(0, test.FindArg(test.executable()));
847    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
848    EXPECT_LT(0, test.FindArg("-merge=1"));
849    EXPECT_LT(0, test.FindArg("-merge_control_file=%s", test.data_path(".mergefile").c_str()));
850    EXPECT_LT(0, test.FindArg(test.data_path("corpus").c_str()));
851    EXPECT_LT(0, test.FindArg(test.data_path("corpus.prev").c_str()));
852
853    // Fuchsia tests
854    ASSERT_TRUE(test.InitFuchsia());
855
856    // Zircon minimizing merge in Fuchsia
857    ASSERT_TRUE(test.Eval("merge zircon/target2"));
858    EXPECT_EQ(ZX_OK, test.Run());
859    EXPECT_EQ(0, test.FindArg(test.executable()));
860    EXPECT_LT(0, test.FindArg(test.manifest()));
861    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
862    EXPECT_LT(0, test.FindArg("-merge=1"));
863    EXPECT_LT(0, test.FindArg("-merge_control_file=%s", test.data_path(".mergefile").c_str()));
864    EXPECT_LT(0, test.FindArg(test.data_path("corpus").c_str()));
865    EXPECT_LT(0, test.FindArg(test.data_path("corpus.prev").c_str()));
866
867    // Can't merge if no corpus
868    ASSERT_TRUE(test.Eval("merge fuchsia1/target1"));
869    EXPECT_NE(ZX_OK, test.Run());
870    EXPECT_TRUE(test.InStdErr("failed"));
871
872    // Fuchsia minimizing merge
873    ASSERT_TRUE(test.Eval("merge fuchsia2/target4"));
874    EXPECT_EQ(ZX_OK, test.Run());
875    EXPECT_EQ(0, test.FindArg(test.executable()));
876    EXPECT_LT(0, test.FindArg(test.manifest()));
877    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
878    EXPECT_LT(0, test.FindArg("-merge=1"));
879    EXPECT_LT(0, test.FindArg("-merge_control_file=%s", test.data_path(".mergefile").c_str()));
880    EXPECT_LT(0, test.FindArg(test.data_path("corpus").c_str()));
881    EXPECT_LT(0, test.FindArg(test.data_path("corpus.prev").c_str()));
882
883    // Fuchsia merge of another corpus without an existing corpus
884    ASSERT_TRUE(test.Eval("merge fuchsia1/target3 /path/to/another/corpus"));
885    EXPECT_EQ(ZX_OK, test.Run());
886    EXPECT_EQ(0, test.FindArg(test.executable()));
887    EXPECT_LT(0, test.FindArg(test.manifest()));
888    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
889    EXPECT_LT(0, test.FindArg("-merge=1"));
890    EXPECT_LT(0, test.FindArg("-merge_control_file=%s", test.data_path(".mergefile").c_str()));
891    EXPECT_LT(0, test.FindArg(test.data_path("corpus").c_str()));
892    EXPECT_LT(0, test.FindArg("/path/to/another/corpus"));
893
894    // Fuchsia merge of another corpus with an existing corpus
895    ASSERT_TRUE(test.Eval("merge fuchsia2/target4 /path/to/another/corpus"));
896    EXPECT_EQ(ZX_OK, test.Run());
897    EXPECT_EQ(0, test.FindArg(test.executable()));
898    EXPECT_LT(0, test.FindArg(test.manifest()));
899    EXPECT_LT(0, test.FindArg("-artifact_prefix=%s", test.data_path()));
900    EXPECT_LT(0, test.FindArg("-merge=1"));
901    EXPECT_LT(0, test.FindArg("-merge_control_file=%s", test.data_path(".mergefile").c_str()));
902    EXPECT_LT(0, test.FindArg(test.data_path("corpus").c_str()));
903    EXPECT_LT(0, test.FindArg("/path/to/another/corpus"));
904
905    END_TEST;
906}
907
908BEGIN_TEST_CASE(FuzzerTest)
909RUN_TEST(TestSetOption)
910RUN_TEST(TestRebasePath)
911RUN_TEST(TestGetPackagePath)
912RUN_TEST(TestFindZirconFuzzers)
913RUN_TEST(TestFindFuchsiaFuzzers)
914RUN_TEST(TestFindFuzzers)
915RUN_TEST(TestCheckProcess)
916RUN_TEST(TestInvalid)
917RUN_TEST(TestHelp)
918RUN_TEST(TestList)
919RUN_TEST(TestSeeds)
920RUN_TEST(TestStart)
921RUN_TEST(TestCheck)
922RUN_TEST(TestStop)
923RUN_TEST(TestRepro)
924RUN_TEST(TestMerge)
925END_TEST_CASE(FuzzerTest)
926
927} // namespace
928} // namespace testing
929} // namespace fuzzing
930