[test] Remove dependent commands.

test/cctest/test-serialize.cc

 // Copyright 2007-2010 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 180 matching lines @@
 #ifdef VERIFY_HEAP
   isolate->heap()->Verify();
 #endif
   CHECK(isolate->global_object()->IsJSObject());
   CHECK(isolate->native_context()->IsContext());
   CHECK(isolate->heap()->string_table()->IsStringTable());
   isolate->factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("Empty"));
 }
 
 
-UNINITIALIZED_DEPENDENT_TEST(Deserialize, Serialize) {
+UNINITIALIZED_TEST(Deserialize) {
   // The serialize-deserialize tests only work if the VM is built without
   // serialization.  That doesn't matter.  We don't need to be able to
   // serialize a snapshot in a VM that is booted from a snapshot.
   DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
-  v8::Isolate* isolate = Deserialize();
+  v8::Isolate* isolate = TestIsolate::NewInitialized(true);
+  Serialize(isolate);
+  isolate = Deserialize();
   {
     v8::HandleScope handle_scope(isolate);
     v8::Isolate::Scope isolate_scope(isolate);
 
     v8::Local<v8::Context> env = v8::Context::New(isolate);
     env->Enter();
 
     SanityCheck(isolate);
   }
   isolate->Dispose();
 }
 
 
-UNINITIALIZED_DEPENDENT_TEST(DeserializeFromSecondSerialization,
-                             SerializeTwice) {
+UNINITIALIZED_TEST(DeserializeFromSecondSerialization) {
   DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
-  v8::Isolate* isolate = Deserialize();
+  v8::Isolate* isolate = TestIsolate::NewInitialized(true);
+  Serialize(isolate);
+  Serialize(isolate);
+  isolate = Deserialize();
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
 
     v8::Local<v8::Context> env = v8::Context::New(isolate);
     env->Enter();
 
     SanityCheck(isolate);
   }
   isolate->Dispose();
 }
 
 
-UNINITIALIZED_DEPENDENT_TEST(DeserializeAndRunScript2, Serialize) {
+UNINITIALIZED_TEST(DeserializeAndRunScript2) {
   DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
-  v8::Isolate* isolate = Deserialize();
+  v8::Isolate* isolate = TestIsolate::NewInitialized(true);
+  Serialize(isolate);

[Michael Achenbach, 2016/03/02 11:22:47]

FYI: The old "Serialize" test doesn't call isolate->Dispose(), so I kept it like
that.

+  isolate = Deserialize();
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
 
 
     v8::Local<v8::Context> env = v8::Context::New(isolate);
     env->Enter();
 
     const char* c_source = "\"1234\".length";
     v8::Local<v8::Script> script = v8_compile(c_source);
     v8::Maybe<int32_t> result = script->Run(isolate->GetCurrentContext())
                                     .ToLocalChecked()
                                     ->Int32Value(isolate->GetCurrentContext());
     CHECK_EQ(4, result.FromJust());
   }
   isolate->Dispose();
 }
 
 
-UNINITIALIZED_DEPENDENT_TEST(DeserializeFromSecondSerializationAndRunScript2,
-                             SerializeTwice) {
+UNINITIALIZED_TEST(DeserializeFromSecondSerializationAndRunScript2) {
   DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
-  v8::Isolate* isolate = Deserialize();
+  v8::Isolate* isolate = TestIsolate::NewInitialized(true);
+  Serialize(isolate);
+  Serialize(isolate);
+  isolate = Deserialize();
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
 
     v8::Local<v8::Context> env = v8::Context::New(isolate);
     env->Enter();
 
     const char* c_source = "\"1234\".length";
     v8::Local<v8::Script> script = v8_compile(c_source);
     v8::Maybe<int32_t> result = script->Run(isolate->GetCurrentContext())
                                     .ToLocalChecked()
                                     ->Int32Value(isolate->GetCurrentContext());
     CHECK_EQ(4, result.FromJust());
   }
   isolate->Dispose();
 }
 
-
-UNINITIALIZED_TEST(PartialSerialization) {
-  DisableTurbofan();
-  if (DefaultSnapshotAvailable()) return;
+static void PartiallySerialize() {
   v8::Isolate* v8_isolate = TestIsolate::NewInitialized(true);
   Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
   v8_isolate->Enter();
   {
     Heap* heap = isolate->heap();
 
     v8::Persistent<v8::Context> env;
     {
       HandleScope scope(isolate);
       env.Reset(v8_isolate, v8::Context::New(v8_isolate));
@@ skipping 48 matching lines @@
     WritePayload(partial_snapshot.RawData(), FLAG_testing_serialization_file);
     WritePayload(startup_snapshot.RawData(), startup_name.start());
 
     startup_name.Dispose();
   }
   v8_isolate->Exit();
   v8_isolate->Dispose();
 }
 
 
-UNINITIALIZED_DEPENDENT_TEST(PartialDeserialization, PartialSerialization) {
+UNINITIALIZED_TEST(PartialSerialization) {
   DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
+  PartiallySerialize();

[Michael Achenbach, 2016/03/02 11:22:47]

For all serialize/deserialize pairs: Do we want the serialize parts to be tested
in isolation, too? The code is also a strict prefix of the deserialize tests.

+}
+
+
+UNINITIALIZED_TEST(PartialDeserialization) {
+  DisableTurbofan();
+  if (DefaultSnapshotAvailable()) return;
+  PartiallySerialize();
   int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
   Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
   SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
   v8::Isolate* v8_isolate = InitializeFromFile(startup_name.start());
   CHECK(v8_isolate);
   startup_name.Dispose();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
@@ skipping 24 matching lines @@
                   .ToHandleChecked();
       CHECK(root2->IsString());
       CHECK(root.is_identical_to(root2));
     }
 
     DeleteArray(snapshot);
   }
   v8_isolate->Dispose();
 }
 
-
-UNINITIALIZED_TEST(ContextSerialization) {
-  DisableTurbofan();
-  if (DefaultSnapshotAvailable()) return;
+static void SerializeContext() {
   v8::Isolate* v8_isolate = TestIsolate::NewInitialized(true);
   Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
   Heap* heap = isolate->heap();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
     v8::Persistent<v8::Context> env;
     {
       HandleScope scope(isolate);
       env.Reset(v8_isolate, v8::Context::New(v8_isolate));
@@ skipping 42 matching lines @@
 
     WritePayload(partial_snapshot.RawData(), FLAG_testing_serialization_file);
     WritePayload(startup_snapshot.RawData(), startup_name.start());
 
     startup_name.Dispose();
   }
   v8_isolate->Dispose();
 }
 
 
-UNINITIALIZED_DEPENDENT_TEST(ContextDeserialization, ContextSerialization) {
+UNINITIALIZED_TEST(ContextSerialization) {
   DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
+  SerializeContext();
+}
+
+
+UNINITIALIZED_TEST(ContextDeserialization) {
+  DisableTurbofan();
+  if (DefaultSnapshotAvailable()) return;
+  SerializeContext();
   int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
   Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
   SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
   v8::Isolate* v8_isolate = InitializeFromFile(startup_name.start());
   CHECK(v8_isolate);
   startup_name.Dispose();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
@@ skipping 24 matching lines @@
                   .ToHandleChecked();
       CHECK(root2->IsContext());
       CHECK(!root.is_identical_to(root2));
     }
     DeleteArray(snapshot);
   }
   v8_isolate->Dispose();
 }
 
 
-UNINITIALIZED_TEST(CustomContextSerialization) {
-  DisableTurbofan();
-  if (DefaultSnapshotAvailable()) return;
+static void SerializeCustomContext() {
   v8::Isolate* v8_isolate = TestIsolate::NewInitialized(true);
   Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
     v8::Persistent<v8::Context> env;
     {
       HandleScope scope(isolate);
       env.Reset(v8_isolate, v8::Context::New(v8_isolate));
     }
@@ skipping 61 matching lines @@
 
     WritePayload(partial_snapshot.RawData(), FLAG_testing_serialization_file);
     WritePayload(startup_snapshot.RawData(), startup_name.start());
 
     startup_name.Dispose();
   }
   v8_isolate->Dispose();
 }
 
 
-UNINITIALIZED_DEPENDENT_TEST(CustomContextDeserialization,
-                             CustomContextSerialization) {
+
+UNINITIALIZED_TEST(CustomContextSerialization) {
+  DisableTurbofan();
+  if (DefaultSnapshotAvailable()) return;
+  SerializeCustomContext();
+}
+
+
+UNINITIALIZED_TEST(CustomContextDeserialization) {
   DisableTurbofan();
   FLAG_crankshaft = false;
   if (DefaultSnapshotAvailable()) return;
+  SerializeCustomContext();
   int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
   Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
   SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
   v8::Isolate* v8_isolate = InitializeFromFile(startup_name.start());
   CHECK(v8_isolate);
   startup_name.Dispose();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
@@ skipping 247 matching lines @@
 TEST(TestThatAlwaysSucceeds) {
 }
 
 
 TEST(TestThatAlwaysFails) {
   bool ArtificialFailure = false;
   CHECK(ArtificialFailure);
 }
 
 
-DEPENDENT_TEST(DependentTestThatAlwaysFails, TestThatAlwaysSucceeds) {
-  bool ArtificialFailure2 = false;
-  CHECK(ArtificialFailure2);
-}
-
-
 int CountBuiltins() {
   // Check that we have not deserialized any additional builtin.
   HeapIterator iterator(CcTest::heap());
   DisallowHeapAllocation no_allocation;
   int counter = 0;
   for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
     if (obj->IsCode() && Code::cast(obj)->kind() == Code::BUILTIN) counter++;
   }
   return counter;
 }
@@ skipping 880 matching lines @@
   delete script_data;
 }
 
 
 TEST(SerializationMemoryStats) {
   FLAG_profile_deserialization = true;
   FLAG_always_opt = false;
   v8::StartupData blob = v8::V8::CreateSnapshotDataBlob();
   delete[] blob.data;
 }