[stubs] Fixed PrimaryStubCache and SecondaryStubCache tests.

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 21463 matching lines @@
   {
     v8::MicrotasksScope scope(env->GetIsolate(),
                               v8::MicrotasksScope::kDoNotRunMicrotasks);
     CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
     CHECK_EQ(3, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
   }
 
   env->GetIsolate()->SetMicrotasksPolicy(v8::MicrotasksPolicy::kAuto);
 }
 
-#if defined(ENABLE_DISASSEMBLER) && !defined(V8_USE_EXTERNAL_STARTUP_DATA)
+#ifdef ENABLE_DISASSEMBLER
 // FLAG_test_primary_stub_cache and FLAG_test_secondary_stub_cache are read
 // only when ENABLE_DISASSEMBLER is not defined.
-// These tests are valid only for no-snapshot mode.
 
 namespace {
 
 int probes_counter = 0;
 int misses_counter = 0;
 int updates_counter = 0;
 
 int* LookupCounter(const char* name) {
   if (strcmp(name, "c:V8.MegamorphicStubCacheProbes") == 0) {
     return &probes_counter;
@@ skipping 32 matching lines @@
     i::FLAG_test_primary_stub_cache = true;
   } else {
     i::FLAG_test_secondary_stub_cache = true;
   }
   i::FLAG_crankshaft = false;
   i::FLAG_turbo = false;
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   create_params.counter_lookup_callback = LookupCounter;
   v8::Isolate* isolate = v8::Isolate::New(create_params);
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
-  {
+  if (!i_isolate->snapshot_available()) {
+    // The test is valid only for no-snapshot mode.
     v8::Isolate::Scope isolate_scope(isolate);
     LocalContext env(isolate);
     v8::HandleScope scope(isolate);
 
     int initial_probes = probes_counter;
     int initial_misses = misses_counter;
     int initial_updates = updates_counter;
     CompileRun(kMegamorphicTestProgram);
     int probes = probes_counter - initial_probes;
     int misses = misses_counter - initial_misses;
@@ skipping 11 matching lines @@
   }
   isolate->Dispose();
 }
 
 }  // namespace
 
 UNINITIALIZED_TEST(PrimaryStubCache) { StubCacheHelper(true); }
 
 UNINITIALIZED_TEST(SecondaryStubCache) { StubCacheHelper(false); }
 
-#endif  // ENABLE_DISASSEMBLER && !V8_USE_EXTERNAL_STARTUP_DATA
+#endif  // ENABLE_DISASSEMBLER
 
 #ifdef DEBUG
 static int cow_arrays_created_runtime = 0;
 
 
 static int* LookupCounterCOWArrays(const char* name) {
   if (strcmp(name, "c:V8.COWArraysCreatedRuntime") == 0) {
     return &cow_arrays_created_runtime;
   }
   return NULL;
@@ skipping 3784 matching lines @@
 }
 
 TEST(PrivateForApiIsNumber) {
   LocalContext context;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   // Shouldn't crash.
   v8::Private::ForApi(isolate, v8_str("42"));
 }