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