Split the testing class into two.

syzygy/integration_tests/instrument_integration_test.cc

 // Copyright 2013 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 329 matching lines @@
       ModuleInformationSet;
 
   using grinder::grinders::ProfileGrinder::PartData;
   using grinder::grinders::ProfileGrinder::PartDataMap;
   using grinder::grinders::ProfileGrinder::PartKey;
 
   using grinder::grinders::ProfileGrinder::modules_;
   using grinder::grinders::ProfileGrinder::parts_;
 };
 
+enum InstrumentationMode {
+  SYZYGY,
+  CLANG,
+};
+
 class LenientInstrumentAppIntegrationTest : public testing::PELibUnitTest {
  public:
   typedef testing::PELibUnitTest Super;
 
   // A callback that gets hooked up to catch exceptions in the RTL.
   MOCK_METHOD1(OnExceptionCallback, void(EXCEPTION_POINTERS*));
 
   LenientInstrumentAppIntegrationTest()
       : cmd_line_(base::FilePath(L"instrument.exe")),
         test_impl_(test_app_.implementation()),
@@ skipping 12 matching lines @@
     this->CreateTemporaryDir(&temp_dir_);
     stdin_path_ = temp_dir_.Append(L"NUL");
     stdout_path_ = temp_dir_.Append(L"stdout.txt");
     stderr_path_ = temp_dir_.Append(L"stderr.txt");
     InitStreams(stdin_path_, stdout_path_, stderr_path_);
 
     // Initialize the (potential) input and output path values.
     base::FilePath abs_input_dll_path_ =
         testing::GetExeRelativePath(testing::kIntegrationTestsDllName);
     input_dll_path_ = testing::GetRelativePath(abs_input_dll_path_);
-    output_dll_path_ = temp_dir_.Append(input_dll_path_.BaseName());
+    test_dll_path_ = temp_dir_.Append(input_dll_path_.BaseName());

[Sébastien Marchand, 2017/08/01 19:27:36]

Don't set this here, as it'll be invalid for the Clang test cases.

[njanevsk, 2017/08/03 01:23:21]

Done.

 
     // Initialize call_service output directory for produced trace files.
     traces_dir_ = temp_dir_.Append(L"traces");
 
     // Initialize call_service session id.
     service_.SetEnvironment();
 
     ASSERT_NO_FATAL_FAILURE(ConfigureTestApp(&test_app_));
   }
 
@@ skipping 20 matching lines @@
   void StopService() {
     service_.Stop();
   }
 
   void UnloadDll() {
     module_.Reset(NULL);
   }
 
   // Runs an instrumentation pass in the given mode and validates that the
   // resulting output DLL loads.
-  void EndToEndTest(const std::string& mode) {
-    cmd_line_.AppendSwitchPath("input-image", input_dll_path_);
-    cmd_line_.AppendSwitchPath("output-image", output_dll_path_);
-    cmd_line_.AppendSwitchASCII("mode", mode);
+  void EndToEndTest(const std::string& mode,
+                    InstrumentationMode instrumentation_mode) {
+    if (instrumentation_mode == SYZYGY) {
+      cmd_line_.AppendSwitchPath("input-image", input_dll_path_);
+      cmd_line_.AppendSwitchPath("output-image", test_dll_path_);
+      cmd_line_.AppendSwitchASCII("mode", mode);
 
-    // Create the instrumented DLL.
-    application::Application<instrument::InstrumentApp> app;
-    ASSERT_NO_FATAL_FAILURE(ConfigureTestApp(&app));
-    ASSERT_EQ(0, app.Run());
-
+      // Create the instrumented DLL.
+      application::Application<instrument::InstrumentApp> app;
+      ASSERT_NO_FATAL_FAILURE(ConfigureTestApp(&app));
+      ASSERT_EQ(0, app.Run());
+    } else if (instrumentation_mode == CLANG) {

[Sébastien Marchand, 2017/08/01 19:27:36]

You don't need this yet as it's not instantiated.

[njanevsk, 2017/08/03 01:23:21]

Done.

+      test_dll_path_ =
+          testing::GetExeRelativePath(testing::kIntegrationTestsClangDllName);
+      printf("%s\n", test_dll_path_.AsUTF8Unsafe().c_str());

[Sébastien Marchand, 2017/08/01 19:27:36]

Remove the debugging code.

[njanevsk, 2017/08/03 01:23:21]

Done.

+    }
     // Validate that the test dll loads post instrumentation.
-    ASSERT_NO_FATAL_FAILURE(LoadTestDll(output_dll_path_, &module_));
+    ASSERT_NO_FATAL_FAILURE(LoadTestDll(test_dll_path_, &module_));
   }
 
   // Invoke a test function inside test_dll by addressing it with a test id.
   // Returns the value resulting from the test function execution.
   unsigned int InvokeTestDllFunction(testing::EndToEndTestId test) {
     // Load the exported 'function_name' function.
     typedef unsigned int (CALLBACK* TestDllFuncs)(unsigned int);
     TestDllFuncs func = reinterpret_cast<TestDllFuncs>(
         ::GetProcAddress(module_, "EndToEndTest"));
     DCHECK(func != NULL);
 
     // Invoke it, and returns its value.
     return func(test);
   }
 
   int RunOutOfProcessFunction(const base::string16& harness_name,
                               testing::EndToEndTestId test,
                               bool expect_exception) {
     base::FilePath harness = testing::GetExeRelativePath(harness_name.c_str());
     base::CommandLine cmd_line(harness);
     cmd_line.AppendSwitchASCII("test", base::StringPrintf("%d", test));
-    cmd_line.AppendSwitchPath("dll", output_dll_path_);
+    cmd_line.AppendSwitchPath("dll", test_dll_path_);
     if (expect_exception)
       cmd_line.AppendSwitch("expect-exception");
 
     base::LaunchOptions options;
     base::Process process = base::LaunchProcess(cmd_line, options);
     EXPECT_TRUE(process.IsValid());
 
     int exit_code = 0;
     EXPECT_TRUE(process.WaitForExit(&exit_code));
     return exit_code;
@@ skipping 101 matching lines @@
         // Memory acessors in the dynamic RTL must be redirected after first
         // use of the function. If the dynamic RTL doesn't redirect the imports
         // everything will still work, just terribly slowly.
         ASSERT_NE(rtl_export_fn, imported_fn);
       } else {
         ASSERT_EQ(rtl_export_fn, imported_fn);
       }
     }
   }
 
-  void EndToEndCheckTestDll() {
-    // Validate that behavior is unchanged after instrumentation.
-    EXPECT_EQ(0xfff80200, InvokeTestDllFunction(testing::kArrayComputation1));
-    EXPECT_EQ(0x00000200, InvokeTestDllFunction(testing::kArrayComputation2));
+  void EndToEndCheckTestDll(InstrumentationMode instrumentation_mode) {
+    if (instrumentation_mode == SYZYGY) {

[Sébastien Marchand, 2017/08/01 19:27:36]

I don't sure that you need this check for now? You're not using the CLANG type
in your instantiation here so there's no need to add the SYZYGY checks until it
breaks.

[njanevsk, 2017/08/03 01:23:21]

Done.

+      // Validate that behavior is unchanged after instrumentation.
+      EXPECT_EQ(0xfff80200, InvokeTestDllFunction(testing::kArrayComputation1));
+      EXPECT_EQ(0x00000200, InvokeTestDllFunction(testing::kArrayComputation2));
+    }
   }
 
   bool AsanErrorCheck(testing::EndToEndTestId test,
                       BadAccessKind kind,
                       AccessMode mode,
                       size_t size,
                       size_t max_tries,
                       bool unload) {
     // A small selection of tests can fail due to hash collisions. These are
     // run repeatedly and expected to pass at least once. Every other test is
@@ skipping 18 matching lines @@
       InvokeTestDllFunction(test);
       if (unload)
         UnloadDll();
 
       // If this appears to have failed then retry it for all but the last
       // attempt. Some tests have a non-zero chance of failure, but their
       // chances of failing repeatedly are infinitesimally small.
       if (asan_error_count == 0 && i + 1 < max_tries) {
         // If the module was unloaded and the test is retrying, then reload it.
         if (unload)
-          EXPECT_NO_FATAL_FAILURE(LoadTestDll(output_dll_path_, &module_));
+          EXPECT_NO_FATAL_FAILURE(LoadTestDll(test_dll_path_, &module_));
         continue;
       }
 
       if (asan_error_count == 0 ||
           last_asan_error.error_type != kind ||
           last_asan_error.access_mode != mode ||
           last_asan_error.access_size != size) {
         return false;
       }
       break;
@@ skipping 242 matching lines @@
 
   void AsanLargeBlockHeapTests(bool expect_exception) {
     OutOfProcessAsanErrorCheckAndValidateLog(
         testing::kAsanReadLargeAllocationTrailerBeforeFree, expect_exception,
         kAsanAccessViolationLog, kAsanHeapBufferOverflow);
     OutOfProcessAsanErrorCheckAndValidateLog(
         testing::kAsanReadLargeAllocationBodyAfterFree, true,
         kAsanAccessViolationLog, kAsanHeapUseAfterFree);
   }
 
-  void AsanZebraHeapTest(bool enabled);

[Sébastien Marchand, 2017/08/01 19:27:36]

Don't remove this function.

[njanevsk, 2017/08/03 01:23:21]

I haven't removed it. I moved it to the Parametrized test class so that the test
cases associated with it can be ran with SYZYGY and CLANG. If those test cases
should be ran only with SYZYGY I can put it back here.

[Sébastien Marchand, 2017/08/03 18:12:59]

Why just this one and not the other Asan*Test functions then? The Parameterized
class derives from this one, so it can use any of the function here.

[Sébastien Marchand, 2017/08/03 20:44:31]

Ha, I just realized that this depends on some things done at instrumentation
time, and so it won't work with Clang yet. I'd just wrap the body of this
function into a "if (GetParam() == SYZYGY)" block then.

[Sébastien Marchand, 2017/08/03 20:46:03]

(the body of the function or the tests, it just feels weird to have only one
function moved out of this class).

-
   void BBEntryInvokeTestDll() {
     EXPECT_EQ(42, InvokeTestDllFunction(testing::kBBEntryCallOnce));
     EXPECT_EQ(42, InvokeTestDllFunction(testing::kBBEntryCallTree));
     EXPECT_EQ(42, InvokeTestDllFunction(testing::kBBEntryCallRecursive));
   }
 
   void ProfileInvokeTestDll() {
     EXPECT_EQ(5, InvokeTestDllFunction(testing::kProfileCallExport));
     // Save the RVA of one of the invoked functions for testing later.
     get_my_rva_ = InvokeTestDllFunction(testing::kProfileGetMyRVA);
@@ skipping 277 matching lines @@
     TestingProfileGrinder::InvocationNodeMap::const_iterator node_it =
         data.nodes_.begin();
     for (; node_it != data.nodes_.end(); ++node_it) {
       if (node_it->second.function.rva() == get_my_rva_)
         return;
     }
 
     FAIL() << "Didn't find GetMyRVA function entry.";
   }
 
+  // Stashes the current log-level before each test instance and restores it
+  // after each test completes.
+  testing::ScopedLogLevelSaver log_level_saver;
+
+  // @name The application under test.
+  // @{
+  TestApp test_app_;
+  TestApp::Implementation& test_impl_;
+  base::FilePath temp_dir_;
+  base::FilePath stdin_path_;
+  base::FilePath stdout_path_;
+  base::FilePath stderr_path_;
+  // @}
+
+  // @name Command-line, parameters and outputs.
+  // @{
+  base::CommandLine cmd_line_;
+  base::FilePath input_dll_path_;
+  base::FilePath test_dll_path_;
+  base::FilePath traces_dir_;
+  // @}
+
+  // The test_dll module.
+  testing::ScopedHMODULE module_;
+
+  // Our call trace service process instance.
+  testing::CallTraceService service_;
+
+  // Decomposed image.
+  pe::PEFile pe_image_;
+  pe::ImageLayout image_layout_;
+  block_graph::BlockGraph block_graph_;
+  uint32_t get_my_rva_;
+};
+
+class ParametrizedLenientInstrumentAppIntegrationTest
+    : public LenientInstrumentAppIntegrationTest,
+      public ::testing::WithParamInterface<InstrumentationMode> {
+ public:
+  void EndToEndTest(const std::string& mode) {
+    LenientInstrumentAppIntegrationTest::EndToEndTest(mode, GetParam());
+  }
+  void AsanZebraHeapTest(bool enabled);
+
+  void EndToEndCheckTestDll() {
+    LenientInstrumentAppIntegrationTest::EndToEndCheckTestDll(GetParam());
+  }
   // Helper function to test the Asan symbolizer script.
   //
   // It starts by running a test with the '--minidump_on_failure' flag turned
   // on and then verify that the generated minidump can be symbolized correctly.
   //
   // @param test_id The test to run.
   // @param kind The expected bad access kind.
   // @param mode The expected bad access mode.
   // @param size The expected bad access size.
   // @param expect_corrupt_heap Indicates if we expect the heap to be corrupt.
   void AsanSymbolizerTest(testing::EndToEndTestId test_id,

[Sébastien Marchand, 2017/08/01 19:27:36]

This could probably be moved to the parent class?

[njanevsk, 2017/08/03 01:23:21]

Done.

                           const char* kind,
                           const char* mode,
                           size_t size,
                           bool expect_corrupt_heap) {
     ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
     ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
 
     // Make sure that a minidump gets produced by the logger when a bug occurs.
     std::unique_ptr<base::Environment> env(base::Environment::Create());
     ASSERT_NE(env.get(), nullptr);
@@ skipping 40 matching lines @@
     EXPECT_TRUE(process.WaitForExit(&exit_code));
     EXPECT_EQ(0u, exit_code);
 
     // Check if the minidump contains a valid protobuf.
     poirot::MinidumpProcessor poirot_processor(
         base::FilePath::FromUTF8Unsafe(minidump_path));
     EXPECT_TRUE(poirot_processor.ProcessDump());
 
     env->UnSetVar(::common::kSyzyAsanOptionsEnvVar);
   }
+};
 
-  // Stashes the current log-level before each test instance and restores it
-  // after each test completes.
-  testing::ScopedLogLevelSaver log_level_saver;
+typedef testing::StrictMock<ParametrizedLenientInstrumentAppIntegrationTest>
+    ParametrizedInstrumentAppIntegrationTest;
 
-  // @name The application under test.
-  // @{
-  TestApp test_app_;
-  TestApp::Implementation& test_impl_;
-  base::FilePath temp_dir_;
-  base::FilePath stdin_path_;
-  base::FilePath stdout_path_;
-  base::FilePath stderr_path_;
-  // @}
-
-  // @name Command-line, parameters and outputs.
-  // @{
-  base::CommandLine cmd_line_;
-  base::FilePath input_dll_path_;
-  base::FilePath output_dll_path_;
-  base::FilePath traces_dir_;
-  // @}
-
-  // The test_dll module.
-  testing::ScopedHMODULE module_;
-
-  // Our call trace service process instance.
-  testing::CallTraceService service_;
-
-  // Decomposed image.
-  pe::PEFile pe_image_;
-  pe::ImageLayout image_layout_;
-  block_graph::BlockGraph block_graph_;
-  uint32_t get_my_rva_;
-};
 typedef testing::StrictMock<LenientInstrumentAppIntegrationTest>
     InstrumentAppIntegrationTest;
 
 typedef std::map<std::string, size_t> FunctionOffsetMap;
 
 // A utility transform for extracting call site offsets from blocks.
 // Used by GetCallOffsets and ZebraBlockHeap tests.
 class ExtractCallTransform
     : public block_graph::BasicBlockSubGraphTransformInterface {
  public:
@@ skipping 65 matching lines @@
   // Apply our dummy transform which simply extracts call addresses.
   {
     ExtractCallTransform bbtx(map);
     block_graph::transforms::ChainedBasicBlockTransforms tx;
     tx.AppendTransform(&bbtx);
     ASSERT_TRUE(block_graph::ApplyBlockGraphTransform(
         &tx, &policy, &bg, header));
   }
 }
 
-void LenientInstrumentAppIntegrationTest::AsanZebraHeapTest(bool enabled) {
+void ParametrizedLenientInstrumentAppIntegrationTest::AsanZebraHeapTest(
+    bool enabled) {
   // Find the offset of the call we want to instrument.
   static const char kTest1[] =
       "testing::AsanReadPageAllocationTrailerBeforeFree";
   static const char kTest2[] =
       "testing::AsanWritePageAllocationBodyAfterFree";
   FunctionOffsetMap map({{kTest1, -1}, {kTest2, -1}});
   ASSERT_NO_FATAL_FAILURE(GetCallOffsets(input_dll_path_, &map));
 
   // Create an allocation filter.
   base::FilePath filter_path = temp_dir_.AppendASCII("allocation_filter.json");
@@ skipping 16 matching lines @@
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanReadPageAllocationTrailerBeforeFreeAllocation, enabled,
       kAsanAccessViolationLog, kAsanHeapBufferOverflow);
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanWritePageAllocationBodyAfterFree, enabled,
       kAsanAccessViolationLog, kAsanHeapUseAfterFree);
 }
 
 }  // namespace
 
-TEST_F(InstrumentAppIntegrationTest, AsanEndToEnd) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanEndToEnd) {
   // Disable the heap checking as this is implies touching all the shadow bytes
   // and this make those tests really slow.
   cmd_line_.AppendSwitchASCII("asan-rtl-options", "--no_check_heap_on_failure");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(CheckTestDllImportsRedirected());
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanEndToEndNoLiveness) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanEndToEndNoLiveness) {
   // Disable the heap checking as this is implies touching all the shadow bytes
   // and this make those tests really slow.
   cmd_line_.AppendSwitchASCII("asan-rtl-options", "--no_check_heap_on_failure");
   cmd_line_.AppendSwitch("no-liveness-analysis");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanEndToEndNoRedundancyAnalysis) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       AsanEndToEndNoRedundancyAnalysis) {
   // Disable the heap checking as this is implies touching all the shadow bytes
   // and this make those tests really slow.
   cmd_line_.AppendSwitchASCII("asan-rtl-options", "--no_check_heap_on_failure");
   cmd_line_.AppendSwitch("no-redundancy-analysis");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanEndToEndNoFunctionInterceptors) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       AsanEndToEndNoFunctionInterceptors) {
   // Disable the heap checking as this is implies touching all the shadow bytes
   // and this make those tests really slow.
   cmd_line_.AppendSwitchASCII("asan-rtl-options", "--no_check_heap_on_failure");
   cmd_line_.AppendSwitch("no-interceptors");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanEndToEndWithRtlOptions) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanEndToEndWithRtlOptions) {
   cmd_line_.AppendSwitchASCII(
       "asan-rtl-options",
       "--quarantine_size=20000000 --quarantine_block_size=1000000 "
       "--no_check_heap_on_failure");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
 
   // Get the active runtime and validate its parameters.
   agent::asan::AsanRuntime* runtime = GetActiveAsanRuntime();
   ASSERT_TRUE(runtime != NULL);
   ASSERT_EQ(20000000u, runtime->params().quarantine_size);
   ASSERT_EQ(1000000u, runtime->params().quarantine_block_size);
 }
 
-TEST_F(InstrumentAppIntegrationTest,
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanEndToEndWithRtlOptionsOverrideWithEnvironment) {
   std::unique_ptr<base::Environment> env(base::Environment::Create());
   ASSERT_NE(env.get(), nullptr);
   env->SetVar(::common::kSyzyAsanOptionsEnvVar,
               "--quarantine_block_size=800000 --ignored_stack_ids=0x1 "
               "--no_check_heap_on_failure");
   cmd_line_.AppendSwitchASCII(
       "asan-rtl-options",
       "--quarantine_size=20000000 --quarantine_block_size=1000000 "
       "--ignored_stack_ids=0x2");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
 
   // Get the active runtime and validate its parameters.
   agent::asan::AsanRuntime* runtime = GetActiveAsanRuntime();
   ASSERT_TRUE(runtime != NULL);
   ASSERT_EQ(20000000u, runtime->params().quarantine_size);
   ASSERT_EQ(800000u, runtime->params().quarantine_block_size);
   ASSERT_THAT(runtime->params().ignored_stack_ids_set,
               testing::ElementsAre(0x1, 0x2));
 
   env->UnSetVar(::common::kSyzyAsanOptionsEnvVar);
 }
 
-TEST_F(InstrumentAppIntegrationTest, FullOptimizedAsanEndToEnd) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest, FullOptimizedAsanEndToEnd) {
   // Disable the heap checking as this implies touching all the shadow bytes
   // and this make these tests really slow.
   cmd_line_.AppendSwitchASCII("asan-rtl-options", "--no_check_heap_on_failure");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckInterceptedFunctions());
 }
 
-TEST_F(InstrumentAppIntegrationTest,
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanInvalidAccessWithCorruptAllocatedBlockHeader) {
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanInvalidAccessWithCorruptAllocatedBlockHeader, true,
       kAsanCorruptHeap, NULL);
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanOverflowCallsCrashForException) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       AsanOverflowCallsCrashForException) {
   // Asan-detected violations go through CrashForException if it is available.
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   int exit_code =
       RunOutOfProcessFunction(L"crash_for_exception_harness.exe",
                               testing::kAsanRead8BufferOverflow, true);
   EXPECT_EQ(kExeCrashForExceptionExitCode, exit_code);
 }
 
-TEST_F(InstrumentAppIntegrationTest,
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanInvalidAccessWithCorruptAllocatedBlockTrailer) {
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanInvalidAccessWithCorruptAllocatedBlockTrailer, true,
       kAsanCorruptHeap, NULL);
 }
 
-TEST_F(InstrumentAppIntegrationTest,
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanInvalidAccessWithCorruptFreedBlock) {
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanInvalidAccessWithCorruptFreedBlock, true, kAsanCorruptHeap,
       NULL);
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanCorruptBlockWithPageProtections) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       AsanCorruptBlockWithPageProtections) {
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanCorruptBlockWithPageProtections, true,
       kAsanHeapUseAfterFree, kAsanCorruptHeap);
 }
 
-TEST_F(InstrumentAppIntegrationTest, SampledAllocationsAsanEndToEnd) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       SampledAllocationsAsanEndToEnd) {
   cmd_line_.AppendSwitchASCII("asan-rtl-options",
                               "--allocation_guard_rate=0.5 "
                               "--no_check_heap_on_failure");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanErrorCheckSampledAllocations());
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanLargeBlockHeapEnabledTest) {
+// The following two tests are timing out when instrumented and run with Clang.

[Sébastien Marchand, 2017/08/01 19:27:36]

Remove this comment as you're not instantiating the Clang test cases yet.

[njanevsk, 2017/08/03 01:23:21]

Done.

+// TODO(njanevsk): Check why the tests are timing out.
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       AsanLargeBlockHeapEnabledTest) {
   cmd_line_.AppendSwitchASCII("asan-rtl-options",
                               "--no_check_heap_on_failure "
                               "--quarantine_size=4000000 "
                               "--quarantine_block_size=2000000");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanLargeBlockHeapTests(true));
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanLargeBlockHeapDisabledTest) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       AsanLargeBlockHeapDisabledTest) {
   cmd_line_.AppendSwitchASCII("asan-rtl-options",
                               "--no_check_heap_on_failure "
                               "--disable_large_block_heap");
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
   ASSERT_NO_FATAL_FAILURE(AsanLargeBlockHeapTests(false));
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanZebraHeapDisabledTest) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanZebraHeapDisabledTest) {
   AsanZebraHeapTest(false);
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanZebraHeapEnabledTest) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanZebraHeapEnabledTest) {
   AsanZebraHeapTest(true);
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanSymbolizerTestAsanBufferOverflow) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       AsanSymbolizerTestAsanBufferOverflow) {
   AsanSymbolizerTest(testing::kAsanRead8BufferOverflow,
                      STRINGIFY(HEAP_BUFFER_OVERFLOW),
                      STRINGIFY(ASAN_READ_ACCESS),
                      1,
                      false);
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanSymbolizerTestAsanBufferUnderflow) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       AsanSymbolizerTestAsanBufferUnderflow) {
   AsanSymbolizerTest(testing::kAsanWrite32BufferUnderflow,
                      STRINGIFY(HEAP_BUFFER_UNDERFLOW),
                      STRINGIFY(ASAN_WRITE_ACCESS),
                      4,
                      false);
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanSymbolizerTestAsanUseAfterFree) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       AsanSymbolizerTestAsanUseAfterFree) {
   AsanSymbolizerTest(testing::kAsanRead64UseAfterFree,
                      STRINGIFY(USE_AFTER_FREE),
                      STRINGIFY(ASAN_READ_ACCESS),
                      8,
                      false);
 }
 
-TEST_F(InstrumentAppIntegrationTest, AsanSymbolizerTestAsanCorruptBlock) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
+       AsanSymbolizerTestAsanCorruptBlock) {
   AsanSymbolizerTest(testing::kAsanCorruptBlock,
                      STRINGIFY(CORRUPT_BLOCK),
                      STRINGIFY(ASAN_UNKNOWN_ACCESS),
                      0,
                      false);
 }
 
-TEST_F(InstrumentAppIntegrationTest,
+TEST_P(ParametrizedInstrumentAppIntegrationTest,
        AsanSymbolizerTestAsanCorruptBlockInQuarantine) {
   AsanSymbolizerTest(testing::kAsanCorruptBlockInQuarantine,
                      STRINGIFY(CORRUPT_BLOCK),
                      STRINGIFY(ASAN_UNKNOWN_ACCESS),
                      0,
                      true);
 }
 
 // These tests require corrupt heap checking to be enabled.
-TEST_F(InstrumentAppIntegrationTest, AsanNearNullptrAccess) {
+TEST_P(ParametrizedInstrumentAppIntegrationTest, AsanNearNullptrAccess) {
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
 
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanNearNullptrAccessHeapCorruptionInstrumented, true,
       kAsanHandlingException, kAsanNearNullptrAccessHeapCorruption);
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanNearNullptrAccessHeapCorruptionUninstrumented, true,
       kAsanHandlingException, kAsanNearNullptrAccessHeapCorruption);
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanNearNullptrAccessNoHeapCorruptionInstrumented, true,
       kAsanHandlingException, kAsanNearNullptrAccessNoHeapCorruption);
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanNearNullptrAccessNoHeapCorruptionUninstrumented, true,
       kAsanHandlingException, kAsanNearNullptrAccessNoHeapCorruption);
   OutOfProcessAsanErrorCheckAndValidateLog(
       testing::kAsanNullptrAccessNoHeapCorruptionUninstrumented, true,
       kAsanHandlingException, kAsanNearNullptrAccessNoHeapCorruption);
 }
 
+// Instantiate the test cases only with SYZYGY until some problems are fixed.
+INSTANTIATE_TEST_CASE_P(InstantiationName,
+                        ParametrizedInstrumentAppIntegrationTest,
+                        testing::Values(SYZYGY));
+
 TEST_F(InstrumentAppIntegrationTest, BBEntryEndToEnd) {
   ASSERT_NO_FATAL_FAILURE(StartService());
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("bbentry"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("bbentry", SYZYGY));

[Sébastien Marchand, 2017/08/01 19:27:36]

I'm not such a fan of having all these extra "SYZYGY" arguments. Could we derive
another class from InstrumentAppIntegrationTest that default to SYZYGY? 

[njanevsk, 2017/08/03 01:23:21]

Done.

+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll(SYZYGY));
   ASSERT_NO_FATAL_FAILURE(BBEntryInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(BBEntryCheckTestDll());
 }
 
 TEST_F(InstrumentAppIntegrationTest, BranchEndToEnd) {
   ASSERT_NO_FATAL_FAILURE(StartService());
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("branch"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("branch", SYZYGY));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll(SYZYGY));
   ASSERT_NO_FATAL_FAILURE(BBEntryInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(UnloadDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(BranchCheckTestDll());
 }
 
 TEST_F(InstrumentAppIntegrationTest, BranchWithBufferingEndToEnd) {
   cmd_line_.AppendSwitch("buffering");
   ASSERT_NO_FATAL_FAILURE(StartService());
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("branch"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("branch", SYZYGY));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll(SYZYGY));
   ASSERT_NO_FATAL_FAILURE(BBEntryInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(UnloadDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(BranchCheckTestDll());
 }
 
 TEST_F(InstrumentAppIntegrationTest, BranchWithSlotEndToEnd) {
   cmd_line_.AppendSwitchASCII("fs-slot", "1");
   ASSERT_NO_FATAL_FAILURE(StartService());
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("branch"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("branch", SYZYGY));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll(SYZYGY));
   ASSERT_NO_FATAL_FAILURE(BBEntryInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(UnloadDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(BranchCheckTestDll());
 }
 
 TEST_F(InstrumentAppIntegrationTest, BranchWithSlotAndBufferingEndToEnd) {
   cmd_line_.AppendSwitch("buffering");
   cmd_line_.AppendSwitchASCII("fs-slot", "1");
   ASSERT_NO_FATAL_FAILURE(StartService());
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("branch"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("branch", SYZYGY));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll(SYZYGY));
   ASSERT_NO_FATAL_FAILURE(BBEntryInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(UnloadDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(BranchCheckTestDll());
 }
 
 TEST_F(InstrumentAppIntegrationTest, CallTraceEndToEnd) {
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("calltrace"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("calltrace", SYZYGY));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll(SYZYGY));
 }
 
 TEST_F(InstrumentAppIntegrationTest, CoverageEndToEnd) {
   base::win::ScopedCOMInitializer scoped_com_initializer;
   ASSERT_NO_FATAL_FAILURE(StartService());
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("coverage"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("coverage", SYZYGY));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll(SYZYGY));
   ASSERT_NO_FATAL_FAILURE(CoverageInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(CoverageCheckTestDll());
 }
 
 TEST_F(InstrumentAppIntegrationTest, BBEntryCoverageEndToEnd) {
   // Coverage grinder must be able to process traces produced by bbentry
   // instrumentation.
   base::win::ScopedCOMInitializer scoped_com_initializer;
   ASSERT_NO_FATAL_FAILURE(StartService());
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("bbentry"));
-  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll());
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("bbentry", SYZYGY));
+  ASSERT_NO_FATAL_FAILURE(EndToEndCheckTestDll(SYZYGY));
   ASSERT_NO_FATAL_FAILURE(CoverageInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(CoverageCheckTestDll());
 }
 
 TEST_F(InstrumentAppIntegrationTest, ProfileEndToEnd) {
   ASSERT_NO_FATAL_FAILURE(StartService());
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("profile"));
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("profile", SYZYGY));
   ASSERT_NO_FATAL_FAILURE(ProfileInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(UnloadDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(ProfileCheckTestDll(false));
 }
 
 TEST_F(InstrumentAppIntegrationTest, ProfileWithImportsEndToEnd) {
   cmd_line_.AppendSwitch("instrument-imports");
   ASSERT_NO_FATAL_FAILURE(StartService());
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("profile"));
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("profile", SYZYGY));
   ASSERT_NO_FATAL_FAILURE(ProfileInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(UnloadDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(ProfileCheckTestDll(true));
 }
 
 TEST_F(InstrumentAppIntegrationTest, DeferredFreeTLS) {
   ASSERT_NO_FATAL_FAILURE(StartService());
-  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
+  ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan", SYZYGY));
   ASSERT_EQ(0, InvokeTestDllFunction(testing::kAsanDeferredFreeTLS));
   ASSERT_NO_FATAL_FAILURE(UnloadDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
 }
 
 }  // namespace integration_tests