therubyracer 0.4.8 → 0.4.9

data/ext/v8/upstream/2.0.6/test/cctest/test-spaces.cc

@@ -1,248 +0,0 @@
-// Copyright 2006-2008 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
-//       with the distribution.
-//     * Neither the name of Google Inc. nor the names of its
-//       contributors may be used to endorse or promote products derived
-//       from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#include <stdlib.h>
-
-#include "v8.h"
-#include "cctest.h"
-
-using namespace v8::internal;
-
-static void VerifyRSet(Address page_start) {
-#ifdef DEBUG
-  Page::set_rset_state(Page::IN_USE);
-#endif
-
-  Page* p = Page::FromAddress(page_start);
-
-  p->ClearRSet();
-
-  for (Address addr = p->ObjectAreaStart();
-       addr < p->ObjectAreaEnd();
-       addr += kPointerSize) {
-    CHECK(!Page::IsRSetSet(addr, 0));
-  }
-
-  for (Address addr = p->ObjectAreaStart();
-       addr < p->ObjectAreaEnd();
-       addr += kPointerSize) {
-    Page::SetRSet(addr, 0);
-  }
-
-  for (Address addr = p->ObjectAreaStart();
-       addr < p->ObjectAreaEnd();
-       addr += kPointerSize) {
-    CHECK(Page::IsRSetSet(addr, 0));
-  }
-}
-
-
-TEST(Page) {
-#ifdef DEBUG
-  Page::set_rset_state(Page::NOT_IN_USE);
-#endif
-
-  byte* mem = NewArray<byte>(2*Page::kPageSize);
-  CHECK(mem != NULL);
-
-  Address start = reinterpret_cast<Address>(mem);
-  Address page_start = RoundUp(start, Page::kPageSize);
-
-  Page* p = Page::FromAddress(page_start);
-  CHECK(p->address() == page_start);
-  CHECK(p->is_valid());
-
-  p->opaque_header = 0;
-  p->is_normal_page = 0x1;
-  CHECK(!p->next_page()->is_valid());
-
-  CHECK(p->ObjectAreaStart() == page_start + Page::kObjectStartOffset);
-  CHECK(p->ObjectAreaEnd() == page_start + Page::kPageSize);
-
-  CHECK(p->Offset(page_start + Page::kObjectStartOffset) ==
-        Page::kObjectStartOffset);
-  CHECK(p->Offset(page_start + Page::kPageSize) == Page::kPageSize);
-
-  CHECK(p->OffsetToAddress(Page::kObjectStartOffset) == p->ObjectAreaStart());
-  CHECK(p->OffsetToAddress(Page::kPageSize) == p->ObjectAreaEnd());
-
-  // test remember set
-  VerifyRSet(page_start);
-
-  DeleteArray(mem);
-}
-
-
-TEST(MemoryAllocator) {
-  CHECK(Heap::ConfigureHeapDefault());
-  CHECK(MemoryAllocator::Setup(Heap::MaxReserved()));
-
-  OldSpace faked_space(Heap::MaxReserved(), OLD_POINTER_SPACE, NOT_EXECUTABLE);
-  int total_pages = 0;
-  int requested = 2;
-  int allocated;
-  // If we request two pages, we should get one or two.
-  Page* first_page =
-      MemoryAllocator::AllocatePages(requested, &allocated, &faked_space);
-  CHECK(first_page->is_valid());
-  CHECK(allocated > 0 && allocated <= 2);
-  total_pages += allocated;
-
-  Page* last_page = first_page;
-  for (Page* p = first_page; p->is_valid(); p = p->next_page()) {
-    CHECK(MemoryAllocator::IsPageInSpace(p, &faked_space));
-    last_page = p;
-  }
-
-  // Again, we should get one or two pages.
-  Page* others =
-      MemoryAllocator::AllocatePages(requested, &allocated, &faked_space);
-  CHECK(others->is_valid());
-  CHECK(allocated > 0 && allocated <= 2);
-  total_pages += allocated;
-
-  MemoryAllocator::SetNextPage(last_page, others);
-  int page_count = 0;
-  for (Page* p = first_page; p->is_valid(); p = p->next_page()) {
-    CHECK(MemoryAllocator::IsPageInSpace(p, &faked_space));
-    page_count++;
-  }
-  CHECK(total_pages == page_count);
-
-  Page* second_page = first_page->next_page();
-  CHECK(second_page->is_valid());
-
-  // Freeing pages at the first chunk starting at or after the second page
-  // should free the entire second chunk.  It will return the last page in the
-  // first chunk (if the second page was in the first chunk) or else an
-  // invalid page (if the second page was the start of the second chunk).
-  Page* free_return = MemoryAllocator::FreePages(second_page);
-  CHECK(free_return == last_page || !free_return->is_valid());
-  MemoryAllocator::SetNextPage(first_page, free_return);
-
-  // Freeing pages in the first chunk starting at the first page should free
-  // the first chunk and return an invalid page.
-  Page* invalid_page = MemoryAllocator::FreePages(first_page);
-  CHECK(!invalid_page->is_valid());
-
-  MemoryAllocator::TearDown();
-}
-
-
-TEST(NewSpace) {
-  CHECK(Heap::ConfigureHeapDefault());
-  CHECK(MemoryAllocator::Setup(Heap::MaxReserved()));
-
-  NewSpace new_space;
-
-  void* chunk =
-      MemoryAllocator::ReserveInitialChunk(4 * Heap::ReservedSemiSpaceSize());
-  CHECK(chunk != NULL);
-  Address start = RoundUp(static_cast<Address>(chunk),
-                          2 * Heap::ReservedSemiSpaceSize());
-  CHECK(new_space.Setup(start, 2 * Heap::ReservedSemiSpaceSize()));
-  CHECK(new_space.HasBeenSetup());
-
-  while (new_space.Available() >= Page::kMaxHeapObjectSize) {
-    Object* obj = new_space.AllocateRaw(Page::kMaxHeapObjectSize);
-    CHECK(!obj->IsFailure());
-    CHECK(new_space.Contains(HeapObject::cast(obj)));
-  }
-
-  new_space.TearDown();
-  MemoryAllocator::TearDown();
-}
-
-
-TEST(OldSpace) {
-  CHECK(Heap::ConfigureHeapDefault());
-  CHECK(MemoryAllocator::Setup(Heap::MaxReserved()));
-
-  OldSpace* s = new OldSpace(Heap::MaxOldGenerationSize(),
-                             OLD_POINTER_SPACE,
-                             NOT_EXECUTABLE);
-  CHECK(s != NULL);
-
-  void* chunk =
-      MemoryAllocator::ReserveInitialChunk(4 * Heap::ReservedSemiSpaceSize());
-  CHECK(chunk != NULL);
-  Address start = static_cast<Address>(chunk);
-  size_t size = RoundUp(start, 2 * Heap::ReservedSemiSpaceSize()) - start;
-
-  CHECK(s->Setup(start, size));
-
-  while (s->Available() > 0) {
-    Object* obj = s->AllocateRaw(Page::kMaxHeapObjectSize);
-    CHECK(!obj->IsFailure());
-  }
-
-  s->TearDown();
-  delete s;
-  MemoryAllocator::TearDown();
-}
-
-
-TEST(LargeObjectSpace) {
-  CHECK(Heap::Setup(false));
-
-  LargeObjectSpace* lo = Heap::lo_space();
-  CHECK(lo != NULL);
-
-  Map* faked_map = reinterpret_cast<Map*>(HeapObject::FromAddress(0));
-  int lo_size = Page::kPageSize;
-
-  Object* obj = lo->AllocateRaw(lo_size);
-  CHECK(!obj->IsFailure());
-  CHECK(obj->IsHeapObject());
-
-  HeapObject* ho = HeapObject::cast(obj);
-  ho->set_map(faked_map);
-
-  CHECK(lo->Contains(HeapObject::cast(obj)));
-
-  CHECK(lo->FindObject(ho->address()) == obj);
-
-  CHECK(lo->Contains(ho));
-
-  while (true) {
-    int available = lo->Available();
-    obj = lo->AllocateRaw(lo_size);
-    if (obj->IsFailure()) break;
-    HeapObject::cast(obj)->set_map(faked_map);
-    CHECK(lo->Available() < available);
-  };
-
-  CHECK(!lo->IsEmpty());
-
-  obj = lo->AllocateRaw(lo_size);
-  CHECK(obj->IsFailure());
-
-  lo->TearDown();
-  delete lo;
-
-  MemoryAllocator::TearDown();
-}

data/ext/v8/upstream/2.0.6/test/cctest/test-strings.cc

@@ -1,432 +0,0 @@
-// Copyright 2006-2008 the V8 project authors. All rights reserved.
-
-// Check that we can traverse very deep stacks of ConsStrings using
-// StringInputBuffer.  Check that Get(int) works on very deep stacks
-// of ConsStrings.  These operations may not be very fast, but they
-// should be possible without getting errors due to too deep recursion.
-
-#include <stdlib.h>
-
-#include "v8.h"
-
-#include "api.h"
-#include "factory.h"
-#include "cctest.h"
-#include "zone-inl.h"
-
-unsigned int seed = 123;
-
-static uint32_t gen() {
-        uint64_t z;
-        z = seed;
-        z *= 279470273;
-        z %= 4294967291U;
-        seed = static_cast<unsigned int>(z);
-        return static_cast<uint32_t>(seed >> 16);
-}
-
-
-using namespace v8::internal;
-
-static v8::Persistent<v8::Context> env;
-
-
-static void InitializeVM() {
-  if (env.IsEmpty()) {
-    v8::HandleScope scope;
-    const char* extensions[] = { "v8/print" };
-    v8::ExtensionConfiguration config(1, extensions);
-    env = v8::Context::New(&config);
-  }
-  v8::HandleScope scope;
-  env->Enter();
-}
-
-
-static const int NUMBER_OF_BUILDING_BLOCKS = 128;
-static const int DEEP_DEPTH = 8 * 1024;
-static const int SUPER_DEEP_DEPTH = 80 * 1024;
-
-
-class Resource: public v8::String::ExternalStringResource,
-                public ZoneObject {
- public:
-  explicit Resource(Vector<const uc16> string): data_(string.start()) {
-    length_ = string.length();
-  }
-  virtual const uint16_t* data() const { return data_; }
-  virtual size_t length() const { return length_; }
-
- private:
-  const uc16* data_;
-  size_t length_;
-};
-
-
-class AsciiResource: public v8::String::ExternalAsciiStringResource,
-                public ZoneObject {
- public:
-  explicit AsciiResource(Vector<const char> string): data_(string.start()) {
-    length_ = string.length();
-  }
-  virtual const char* data() const { return data_; }
-  virtual size_t length() const { return length_; }
-
- private:
-  const char* data_;
-  size_t length_;
-};
-
-
-static void InitializeBuildingBlocks(
-    Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS]) {
-  // A list of pointers that we don't have any interest in cleaning up.
-  // If they are reachable from a root then leak detection won't complain.
-  for (int i = 0; i < NUMBER_OF_BUILDING_BLOCKS; i++) {
-    int len = gen() % 16;
-    if (len > 14) {
-      len += 1234;
-    }
-    switch (gen() % 4) {
-      case 0: {
-        uc16 buf[2000];
-        for (int j = 0; j < len; j++) {
-          buf[j] = gen() % 65536;
-        }
-        building_blocks[i] =
-            Factory::NewStringFromTwoByte(Vector<const uc16>(buf, len));
-        for (int j = 0; j < len; j++) {
-          CHECK_EQ(buf[j], building_blocks[i]->Get(j));
-        }
-        break;
-      }
-      case 1: {
-        char buf[2000];
-        for (int j = 0; j < len; j++) {
-          buf[j] = gen() % 128;
-        }
-        building_blocks[i] =
-            Factory::NewStringFromAscii(Vector<const char>(buf, len));
-        for (int j = 0; j < len; j++) {
-          CHECK_EQ(buf[j], building_blocks[i]->Get(j));
-        }
-        break;
-      }
-      case 2: {
-        uc16* buf = Zone::NewArray<uc16>(len);
-        for (int j = 0; j < len; j++) {
-          buf[j] = gen() % 65536;
-        }
-        Resource* resource = new Resource(Vector<const uc16>(buf, len));
-        building_blocks[i] = Factory::NewExternalStringFromTwoByte(resource);
-        for (int j = 0; j < len; j++) {
-          CHECK_EQ(buf[j], building_blocks[i]->Get(j));
-        }
-        break;
-      }
-      case 3: {
-        char* buf = NewArray<char>(len);
-        for (int j = 0; j < len; j++) {
-          buf[j] = gen() % 128;
-        }
-        building_blocks[i] =
-            Factory::NewStringFromAscii(Vector<const char>(buf, len));
-        for (int j = 0; j < len; j++) {
-          CHECK_EQ(buf[j], building_blocks[i]->Get(j));
-        }
-        DeleteArray<char>(buf);
-        break;
-      }
-    }
-  }
-}
-
-
-static Handle<String> ConstructLeft(
-    Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS],
-    int depth) {
-  Handle<String> answer = Factory::NewStringFromAscii(CStrVector(""));
-  for (int i = 0; i < depth; i++) {
-    answer = Factory::NewConsString(
-        answer,
-        building_blocks[i % NUMBER_OF_BUILDING_BLOCKS]);
-  }
-  return answer;
-}
-
-
-static Handle<String> ConstructRight(
-    Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS],
-    int depth) {
-  Handle<String> answer = Factory::NewStringFromAscii(CStrVector(""));
-  for (int i = depth - 1; i >= 0; i--) {
-    answer = Factory::NewConsString(
-        building_blocks[i % NUMBER_OF_BUILDING_BLOCKS],
-        answer);
-  }
-  return answer;
-}
-
-
-static Handle<String> ConstructBalancedHelper(
-    Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS],
-    int from,
-    int to) {
-  CHECK(to > from);
-  if (to - from == 1) {
-    return building_blocks[from % NUMBER_OF_BUILDING_BLOCKS];
-  }
-  if (to - from == 2) {
-    return Factory::NewConsString(
-        building_blocks[from % NUMBER_OF_BUILDING_BLOCKS],
-        building_blocks[(from+1) % NUMBER_OF_BUILDING_BLOCKS]);
-  }
-  Handle<String> part1 =
-    ConstructBalancedHelper(building_blocks, from, from + ((to - from) / 2));
-  Handle<String> part2 =
-    ConstructBalancedHelper(building_blocks, from + ((to - from) / 2), to);
-  return Factory::NewConsString(part1, part2);
-}
-
-
-static Handle<String> ConstructBalanced(
-    Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS]) {
-  return ConstructBalancedHelper(building_blocks, 0, DEEP_DEPTH);
-}
-
-
-static StringInputBuffer buffer;
-
-
-static void Traverse(Handle<String> s1, Handle<String> s2) {
-  int i = 0;
-  buffer.Reset(*s1);
-  StringInputBuffer buffer2(*s2);
-  while (buffer.has_more()) {
-    CHECK(buffer2.has_more());
-    uint16_t c = buffer.GetNext();
-    CHECK_EQ(c, buffer2.GetNext());
-    i++;
-  }
-  CHECK_EQ(s1->length(), i);
-  CHECK_EQ(s2->length(), i);
-}
-
-
-static void TraverseFirst(Handle<String> s1, Handle<String> s2, int chars) {
-  int i = 0;
-  buffer.Reset(*s1);
-  StringInputBuffer buffer2(*s2);
-  while (buffer.has_more() && i < chars) {
-    CHECK(buffer2.has_more());
-    uint16_t c = buffer.GetNext();
-    CHECK_EQ(c, buffer2.GetNext());
-    i++;
-  }
-  s1->Get(s1->length() - 1);
-  s2->Get(s2->length() - 1);
-}
-
-
-TEST(Traverse) {
-  printf("TestTraverse\n");
-  InitializeVM();
-  v8::HandleScope scope;
-  Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS];
-  ZoneScope zone(DELETE_ON_EXIT);
-  InitializeBuildingBlocks(building_blocks);
-  Handle<String> flat = ConstructBalanced(building_blocks);
-  FlattenString(flat);
-  Handle<String> left_asymmetric = ConstructLeft(building_blocks, DEEP_DEPTH);
-  Handle<String> right_asymmetric = ConstructRight(building_blocks, DEEP_DEPTH);
-  Handle<String> symmetric = ConstructBalanced(building_blocks);
-  printf("1\n");
-  Traverse(flat, symmetric);
-  printf("2\n");
-  Traverse(flat, left_asymmetric);
-  printf("3\n");
-  Traverse(flat, right_asymmetric);
-  printf("4\n");
-  Handle<String> left_deep_asymmetric =
-      ConstructLeft(building_blocks, SUPER_DEEP_DEPTH);
-  Handle<String> right_deep_asymmetric =
-      ConstructRight(building_blocks, SUPER_DEEP_DEPTH);
-  printf("5\n");
-  TraverseFirst(left_asymmetric, left_deep_asymmetric, 1050);
-  printf("6\n");
-  TraverseFirst(left_asymmetric, right_deep_asymmetric, 65536);
-  printf("7\n");
-  FlattenString(left_asymmetric);
-  printf("10\n");
-  Traverse(flat, left_asymmetric);
-  printf("11\n");
-  FlattenString(right_asymmetric);
-  printf("12\n");
-  Traverse(flat, right_asymmetric);
-  printf("14\n");
-  FlattenString(symmetric);
-  printf("15\n");
-  Traverse(flat, symmetric);
-  printf("16\n");
-  FlattenString(left_deep_asymmetric);
-  printf("18\n");
-}
-
-
-static const int DEEP_ASCII_DEPTH = 100000;
-
-
-TEST(DeepAscii) {
-  printf("TestDeepAscii\n");
-  InitializeVM();
-  v8::HandleScope scope;
-
-  char* foo = NewArray<char>(DEEP_ASCII_DEPTH);
-  for (int i = 0; i < DEEP_ASCII_DEPTH; i++) {
-    foo[i] = "foo "[i % 4];
-  }
-  Handle<String> string =
-      Factory::NewStringFromAscii(Vector<const char>(foo, DEEP_ASCII_DEPTH));
-  Handle<String> foo_string = Factory::NewStringFromAscii(CStrVector("foo"));
-  for (int i = 0; i < DEEP_ASCII_DEPTH; i += 10) {
-    string = Factory::NewConsString(string, foo_string);
-  }
-  Handle<String> flat_string = Factory::NewConsString(string, foo_string);
-  FlattenString(flat_string);
-
-  for (int i = 0; i < 500; i++) {
-    TraverseFirst(flat_string, string, DEEP_ASCII_DEPTH);
-  }
-  DeleteArray<char>(foo);
-}
-
-
-TEST(Utf8Conversion) {
-  // Smoke test for converting strings to utf-8.
-  InitializeVM();
-  v8::HandleScope handle_scope;
-  // A simple ascii string
-  const char* ascii_string = "abcdef12345";
-  int len =
-      v8::String::New(ascii_string,
-                      StrLength(ascii_string))->Utf8Length();
-  CHECK_EQ(StrLength(ascii_string), len);
-  // A mixed ascii and non-ascii string
-  // U+02E4 -> CB A4
-  // U+0064 -> 64
-  // U+12E4 -> E1 8B A4
-  // U+0030 -> 30
-  // U+3045 -> E3 81 85
-  const uint16_t mixed_string[] = {0x02E4, 0x0064, 0x12E4, 0x0030, 0x3045};
-  // The characters we expect to be output
-  const unsigned char as_utf8[11] = {0xCB, 0xA4, 0x64, 0xE1, 0x8B, 0xA4, 0x30,
-      0xE3, 0x81, 0x85, 0x00};
-  // The number of bytes expected to be written for each length
-  const int lengths[12] = {0, 0, 2, 3, 3, 3, 6, 7, 7, 7, 10, 11};
-  v8::Handle<v8::String> mixed = v8::String::New(mixed_string, 5);
-  CHECK_EQ(10, mixed->Utf8Length());
-  // Try encoding the string with all capacities
-  char buffer[11];
-  const char kNoChar = static_cast<char>(-1);
-  for (int i = 0; i <= 11; i++) {
-    // Clear the buffer before reusing it
-    for (int j = 0; j < 11; j++)
-      buffer[j] = kNoChar;
-    int written = mixed->WriteUtf8(buffer, i);
-    CHECK_EQ(lengths[i], written);
-    // Check that the contents are correct
-    for (int j = 0; j < lengths[i]; j++)
-      CHECK_EQ(as_utf8[j], static_cast<unsigned char>(buffer[j]));
-    // Check that the rest of the buffer hasn't been touched
-    for (int j = lengths[i]; j < 11; j++)
-      CHECK_EQ(kNoChar, buffer[j]);
-  }
-}
-
-
-TEST(ExternalShortStringAdd) {
-  ZoneScope zone(DELETE_ON_EXIT);
-
-  InitializeVM();
-  v8::HandleScope handle_scope;
-
-  // Make sure we cover all always-flat lengths and at least one above.
-  static const int kMaxLength = 20;
-  CHECK_GT(kMaxLength, i::String::kMinNonFlatLength);
-
-  // Allocate two JavaScript arrays for holding short strings.
-  v8::Handle<v8::Array> ascii_external_strings =
-      v8::Array::New(kMaxLength + 1);
-  v8::Handle<v8::Array> non_ascii_external_strings =
-      v8::Array::New(kMaxLength + 1);
-
-  // Generate short ascii and non-ascii external strings.
-  for (int i = 0; i <= kMaxLength; i++) {
-    char* ascii = Zone::NewArray<char>(i + 1);
-    for (int j = 0; j < i; j++) {
-      ascii[j] = 'a';
-    }
-    // Terminating '\0' is left out on purpose. It is not required for external
-    // string data.
-    AsciiResource* ascii_resource =
-        new AsciiResource(Vector<const char>(ascii, i));
-    v8::Local<v8::String> ascii_external_string =
-        v8::String::NewExternal(ascii_resource);
-
-    ascii_external_strings->Set(v8::Integer::New(i), ascii_external_string);
-    uc16* non_ascii = Zone::NewArray<uc16>(i + 1);
-    for (int j = 0; j < i; j++) {
-      non_ascii[j] = 0x1234;
-    }
-    // Terminating '\0' is left out on purpose. It is not required for external
-    // string data.
-    Resource* resource = new Resource(Vector<const uc16>(non_ascii, i));
-    v8::Local<v8::String> non_ascii_external_string =
-      v8::String::NewExternal(resource);
-    non_ascii_external_strings->Set(v8::Integer::New(i),
-                                    non_ascii_external_string);
-  }
-
-  // Add the arrays with the short external strings in the global object.
-  v8::Handle<v8::Object> global = env->Global();
-  global->Set(v8_str("external_ascii"), ascii_external_strings);
-  global->Set(v8_str("external_non_ascii"), non_ascii_external_strings);
-  global->Set(v8_str("max_length"), v8::Integer::New(kMaxLength));
-
-  // Add short external ascii and non-ascii strings checking the result.
-  static const char* source =
-    "function test() {"
-    "  var ascii_chars = 'aaaaaaaaaaaaaaaaaaaa';"
-    "  var non_ascii_chars = '\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234\\u1234';"  //NOLINT
-    "  if (ascii_chars.length != max_length) return 1;"
-    "  if (non_ascii_chars.length != max_length) return 2;"
-    "  var ascii = Array(max_length + 1);"
-    "  var non_ascii = Array(max_length + 1);"
-    "  for (var i = 0; i <= max_length; i++) {"
-    "    ascii[i] = ascii_chars.substring(0, i);"
-    "    non_ascii[i] = non_ascii_chars.substring(0, i);"
-    "  };"
-    "  for (var i = 0; i <= max_length; i++) {"
-    "    if (ascii[i] != external_ascii[i]) return 3;"
-    "    if (non_ascii[i] != external_non_ascii[i]) return 4;"
-    "    for (var j = 0; j < i; j++) {"
-    "      if (external_ascii[i] !="
-    "          (external_ascii[j] + external_ascii[i - j])) return 5;"
-    "      if (external_non_ascii[i] !="
-    "          (external_non_ascii[j] + external_non_ascii[i - j])) return 6;"
-    "      if (non_ascii[i] != (non_ascii[j] + non_ascii[i - j])) return 7;"
-    "      if (ascii[i] != (ascii[j] + ascii[i - j])) return 8;"
-    "      if (ascii[i] != (external_ascii[j] + ascii[i - j])) return 9;"
-    "      if (ascii[i] != (ascii[j] + external_ascii[i - j])) return 10;"
-    "      if (non_ascii[i] !="
-    "          (external_non_ascii[j] + non_ascii[i - j])) return 11;"
-    "      if (non_ascii[i] !="
-    "          (non_ascii[j] + external_non_ascii[i - j])) return 12;"
-    "    }"
-    "  }"
-    "  return 0;"
-    "};"
-    "test()";
-  CHECK_EQ(0,
-           v8::Script::Compile(v8::String::New(source))->Run()->Int32Value());
-}