[wasm] Test deserialized module still has bytes, + negative test

test/cctest/wasm/test-run-wasm-module.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/snapshot/code-serializer.h"
 #include "src/version.h"
 #include "src/wasm/module-decoder.h"
@@ skipping 212 matching lines @@
 
   v8::WasmCompiledModule::CallerOwnedBuffer wire_bytes = {
       const_cast<const uint8_t*>(bytes), bytes_size};
 
   v8::WasmCompiledModule::CallerOwnedBuffer serialized_bytes = {
       data.first.get(), data.second};
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator =
       CcTest::InitIsolateOnce()->array_buffer_allocator();
 
-  for (int i = 0; i < 3; ++i) {
+  for (int i = 0; i < 4; ++i) {

[bradnelson, 2016/10/17 20:38:04]

The numeric counting is getting hard to follow here.
Turn into a TEST_F ?

[Mircea Trofin, 2016/10/18 04:34:13]

Currently, TEST_F isn't available to cctest. I refactored along the lines of a
TEST_F, to move forward, and will investigate the motivation for not using the
gtest framework in cctests. At minimum, the tests are more readable now.

     v8::Isolate* v8_isolate = v8::Isolate::New(create_params);
     if (i == 1) {
       // Invalidate the header by providing a mismatched version
       uint32_t* buffer = reinterpret_cast<uint32_t*>(
           const_cast<uint8_t*>(serialized_bytes.first));
       buffer[SerializedCodeData::kVersionHashOffset] = Version::Hash() + 1;
     }
 
     if (i == 2) {
       // Provide no serialized data to force recompilation.
       serialized_bytes.first = nullptr;
       serialized_bytes.second = 0;
     }
+    if (i == 3) {
+      // Not even the wire bytes are valid. Clear half of them.
+      memset(const_cast<uint8_t*>(wire_bytes.first), '\0',
+             wire_bytes.second / 2);
+    }
     {
       v8::Isolate::Scope isolate_scope(v8_isolate);
       v8::HandleScope new_scope(v8_isolate);
       v8::Local<v8::Context> new_ctx = v8::Context::New(v8_isolate);
       new_ctx->Enter();
       isolate = reinterpret_cast<Isolate*>(v8_isolate);
       testing::SetupIsolateForWasmModule(isolate);
       v8::MaybeLocal<v8::WasmCompiledModule> deserialized =
           v8::WasmCompiledModule::DeserializeOrCompile(
               v8_isolate, serialized_bytes, wire_bytes);
-      v8::Local<v8::WasmCompiledModule> compiled_module;
-      CHECK(deserialized.ToLocal(&compiled_module));
-      Handle<JSObject> module_object =
-          Handle<JSObject>::cast(v8::Utils::OpenHandle(*compiled_module));
-      Handle<JSObject> instance =
-          WasmModule::Instantiate(isolate, &thrower, module_object,
-                                  Handle<JSReceiver>::null(),
-                                  Handle<JSArrayBuffer>::null())
-              .ToHandleChecked();
-      Handle<Object> params[1] = {Handle<Object>(Smi::FromInt(41), isolate)};
-      int32_t result = testing::CallWasmFunctionForTesting(
-          isolate, instance, &thrower, kFunctionName, 1, params,
-          ModuleOrigin::kWasmOrigin);
-      CHECK(result == 42);
+      if (i == 3) {
+        CHECK(deserialized.IsEmpty());
+      } else {
+        v8::Local<v8::WasmCompiledModule> deserialized_module;
+        CHECK(deserialized.ToLocal(&deserialized_module));
+        Handle<JSObject> module_object =
+            Handle<JSObject>::cast(v8::Utils::OpenHandle(*deserialized_module));
+        {
+          DisallowHeapAllocation assume_no_gc;
+          Handle<WasmCompiledModule> compiled_part(
+              WasmCompiledModule::cast(module_object->GetInternalField(0)),
+              isolate);
+          CHECK_EQ(memcmp(compiled_part->module_bytes()->GetCharsAddress(),
+                          wire_bytes.first, wire_bytes.second),
+                   0);
+        }
+        Handle<JSObject> instance =
+            WasmModule::Instantiate(isolate, &thrower, module_object,
+                                    Handle<JSReceiver>::null(),
+                                    Handle<JSArrayBuffer>::null())
+                .ToHandleChecked();
+        Handle<Object> params[1] = {Handle<Object>(Smi::FromInt(41), isolate)};
+        int32_t result = testing::CallWasmFunctionForTesting(
+            isolate, instance, &thrower, kFunctionName, 1, params,
+            ModuleOrigin::kWasmOrigin);
+        CHECK(result == 42);
+      }
       new_ctx->Exit();
     }
     v8_isolate->Dispose();
   }
 }
 
 TEST(MemorySize) {
   // Initial memory size is 16, see wasm-module-builder.cc
   static const int kExpectedValue = 16;
   TestSignatures sigs;
@@ skipping 338 matching lines @@
 
 TEST(Run_WasmModule_Global_f32) {
   RunWasmModuleGlobalInitTest<float>(kAstF32, -983.9f);
   RunWasmModuleGlobalInitTest<float>(kAstF32, 1122.99f);
 }
 
 TEST(Run_WasmModule_Global_f64) {
   RunWasmModuleGlobalInitTest<double>(kAstF64, -833.9);
   RunWasmModuleGlobalInitTest<double>(kAstF64, 86374.25);
 }