Not for committing. Proof that NaCl stuff is insane.

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 14826 matching lines @@
   v8::ScriptData* sd = v8::ScriptData::New(data, invalid_size);
 
   CHECK_EQ(0, sd->Length());
 
   delete sd;
 }
 
 
 // Attempts to deserialize bad data.
 TEST(PreCompileInvalidPreparseDataError) {
+  fprintf(stderr, "Test 1\n");
   v8::V8::Initialize();
   v8::Isolate* isolate = CcTest::isolate();
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   const char* script = "function foo(){ return 5;}\n"
       "function bar(){ return 6 + 7;}  foo();";
+  fprintf(stderr, "Test 2\n");
   v8::ScriptData* sd = v8::ScriptData::PreCompile(v8::String::NewFromUtf8(
       isolate, script, v8::String::kNormalString, i::StrLength(script)));
   CHECK(!sd->HasError());
+  fprintf(stderr, "Test 3\n");
   // ScriptDataImpl private implementation details
   const int kHeaderSize = i::PreparseDataConstants::kHeaderSize;
   const int kFunctionEntrySize = i::FunctionEntry::kSize;
   const int kFunctionEntryStartOffset = 0;
   const int kFunctionEntryEndOffset = 1;
   unsigned* sd_data =
       reinterpret_cast<unsigned*>(const_cast<char*>(sd->Data()));
 
+  fprintf(stderr, "Test 4\n");
   // Overwrite function bar's end position with 0.
   sd_data[kHeaderSize + 1 * kFunctionEntrySize + kFunctionEntryEndOffset] = 0;
+  fprintf(stderr, "Test 5\n");
   v8::TryCatch try_catch;
 
+  fprintf(stderr, "Test 6\n");
   Local<String> source = String::NewFromUtf8(isolate, script);
+  fprintf(stderr, "Test 6b\n");
   Local<Script> compiled_script = Script::New(source, NULL, sd);
+  fprintf(stderr, "Test 7\n");
   CHECK(try_catch.HasCaught());
   String::Utf8Value exception_value(try_catch.Message()->Get());
   CHECK_EQ("Uncaught SyntaxError: Invalid preparser data for function bar",
            *exception_value);
 
   try_catch.Reset();
+  fprintf(stderr, "Test 8\n");
   delete sd;
+  fprintf(stderr, "Test 9\n");
 
   // Overwrite function bar's start position with 200.  The function entry
   // will not be found when searching for it by position and we should fall
   // back on eager compilation.
   sd = v8::ScriptData::PreCompile(v8::String::NewFromUtf8(
       isolate, script, v8::String::kNormalString, i::StrLength(script)));
+  fprintf(stderr, "Test 10\n");
   sd_data = reinterpret_cast<unsigned*>(const_cast<char*>(sd->Data()));
   sd_data[kHeaderSize + 1 * kFunctionEntrySize + kFunctionEntryStartOffset] =
       200;
+  fprintf(stderr, "Test 11\n");
   compiled_script = Script::New(source, NULL, sd);
   CHECK(!try_catch.HasCaught());
 
+  fprintf(stderr, "Test 12\n");
   delete sd;
+  fprintf(stderr, "Test 13\n");
 }
 
 
 // This tests that we do not allow dictionary load/call inline caches
 // to use functions that have not yet been compiled.  The potential
 // problem of loading a function that has not yet been compiled can
 // arise because we share code between contexts via the compilation
 // cache.
 THREADED_TEST(DictionaryICLoadedFunction) {
   v8::HandleScope scope(CcTest::isolate());
@@ skipping 7057 matching lines @@
 
 
 TEST(TestFunctionCallOptimization) {
   i::FLAG_allow_natives_syntax = true;
   ApiCallOptimizationChecker checker;
   checker.Run(true, true);
   checker.Run(false, true);
   checker.Run(true, false);
   checker.Run(false, false);
 }
+
+void DoStuff(i::Vector<const char*> args) {
+  fprintf(stderr, "len is %d\n", args.length());
+}
+
+
+TEST(Foo) {
+  const char* element[1] = { "foo" };
+  i::Vector<const char*> args(element, 1);
+  fprintf(stderr, "len is %d\n", args.length());
+  DoStuff(args);
+  CHECK(false);
+}