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());
 
     // 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) {
+  virtual void EndToEndTest(const std::string& mode) {
     cmd_line_.AppendSwitchPath("input-image", input_dll_path_);
-    cmd_line_.AppendSwitchPath("output-image", output_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());
 
     // 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() {
+  virtual void EndToEndCheckTestDll() {
     // 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,
@@ skipping 21 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 631 matching lines @@
   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 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 created to enable parametrization of the tests with clang.

[Sébastien Marchand, 2017/08/07 18:21:50]

Clang.

+// Currently only Syzygy is supported but will be extended to work with CLANG.
+// Rigth now it just forwards the calls to the parent class.

[Sébastien Marchand, 2017/08/07 18:21:50]

right.

+class ParametrizedLenientInstrumentAppIntegrationTest
+    : public LenientInstrumentAppIntegrationTest,
+      public ::testing::WithParamInterface<InstrumentationMode> {
+ public:
+  void EndToEndTest(const std::string& mode) override {
+    if (GetParam() == SYZYGY) {
+      LenientInstrumentAppIntegrationTest::EndToEndTest(mode);
+    }
+  }
+
+  void EndToEndCheckTestDll() override {
+    if (GetParam() == SYZYGY) {
+      LenientInstrumentAppIntegrationTest::EndToEndCheckTestDll();
+    }
+  }
+};
+
+typedef testing::StrictMock<ParametrizedLenientInstrumentAppIntegrationTest>
+    ParametrizedInstrumentAppIntegrationTest;
+
 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 102 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) {
+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(BBEntryInvokeTestDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
   ASSERT_NO_FATAL_FAILURE(BBEntryCheckTestDll());
 }
 
 TEST_F(InstrumentAppIntegrationTest, BranchEndToEnd) {
@@ skipping 88 matching lines @@
 
 TEST_F(InstrumentAppIntegrationTest, DeferredFreeTLS) {
   ASSERT_NO_FATAL_FAILURE(StartService());
   ASSERT_NO_FATAL_FAILURE(EndToEndTest("asan"));
   ASSERT_EQ(0, InvokeTestDllFunction(testing::kAsanDeferredFreeTLS));
   ASSERT_NO_FATAL_FAILURE(UnloadDll());
   ASSERT_NO_FATAL_FAILURE(StopService());
 }
 
 }  // namespace integration_tests