CSE2410 Fall 2014 Bounce

                                     Zone* zone) {

  // 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.

  Factory* factory = isolate->factory();

  for (int i = 0; i < bb_length; i++) {

    int len = rng->next(16);

  rng_.init();

  InitializeBuildingBlocks(

      building_blocks_, kNumberOfBuildingBlocks, long_blocks, &rng_, zone);

  Reset();

}

static Handle<String> ConstructRandomString(ConsStringGenerationData* data,

                                            unsigned max_recursion) {

  // Compute termination characteristics.

  bool terminate = false;

  bool flat = data->rng_.next(data->empty_leaf_threshold_);

static Handle<String> ConstructLeft(

    ConsStringGenerationData* data,

    int depth) {

  Handle<String> answer = factory->NewStringFromAscii(CStrVector(""));

  data->stats_.leaves_++;

  for (int i = 0; i < depth; i++) {

static Handle<String> ConstructRight(

    ConsStringGenerationData* data,

    int depth) {

  Handle<String> answer = factory->NewStringFromAscii(CStrVector(""));

  data->stats_.leaves_++;

  for (int i = depth - 1; i >= 0; i--) {

    ConsStringGenerationData* data,

    int from,

    int to) {

  CHECK(to > from);

  if (to - from == 1) {

    data->stats_.chars_ += data->block(from)->length();

  printf("TestTraverse\n");

  CcTest::InitializeVM();

  v8::HandleScope scope(CcTest::isolate());

  ConsStringGenerationData data(false, &zone);

  Handle<String> flat = ConstructBalanced(&data);

  FlattenString(flat);

template<typename BuildString>

void TestStringCharacterStream(BuildString build, int test_cases) {

  CcTest::InitializeVM();

  HandleScope outer_scope(isolate);

  Zone zone(isolate);

  ConsStringGenerationData data(true, &zone);

static Handle<String> BuildEdgeCaseConsString(

    int test_case, ConsStringGenerationData* data) {

  data->Reset();

  switch (test_case) {

    case 0:

TEST(DeepAscii) {

  printf("TestDeepAscii\n");

  CcTest::InitializeVM();

  v8::HandleScope scope(CcTest::isolate());

  char* foo = NewArray<char>(DEEP_ASCII_DEPTH);

TEST(ExternalShortStringAdd) {

  Zone zone(isolate);

  v8::HandleScope handle_scope(CcTest::isolate());

  // Make sure we cover all always-flat lengths and at least one above.

  }

  // Add the arrays with the short external strings in the global object.

  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));

TEST(JSONStringifySliceMadeExternal) {

  CcTest::InitializeVM();

  // Create a sliced string from a one-byte string.  The latter is turned

  // into a two-byte external string.  Check that JSON.stringify works.

  v8::HandleScope handle_scope(CcTest::isolate());

TEST(CachedHashOverflow) {

  // We incorrectly allowed strings to be tagged as array indices even if their

  // values didn't fit in the hash field.

  // See http://code.google.com/p/v8/issues/detail?id=728

  Zone zone(isolate);

  v8::HandleScope handle_scope(CcTest::isolate());

  // Lines must be executed sequentially. Combining them into one script

  // makes the bug go away.

TEST(SliceFromCons) {

  FLAG_string_slices = true;

  CcTest::InitializeVM();

  v8::HandleScope scope(CcTest::isolate());

  Handle<String> string =

      factory->NewStringFromAscii(CStrVector("parentparentparent"));

TEST(SliceFromExternal) {

  FLAG_string_slices = true;

  CcTest::InitializeVM();

  v8::HandleScope scope(CcTest::isolate());

  AsciiVectorResource resource(

      i::Vector<const char>("abcdefghijklmnopqrstuvwxyz", 26));

  // actually creates a new string (it should not).

  FLAG_string_slices = true;

  CcTest::InitializeVM();

  v8::HandleScope scope(CcTest::isolate());

  v8::Local<v8::Value> result;

  Handle<String> string;

      "for (var i = 1; i <= two_14; i++) a.push(s);"

      "a.join("");";

  LocalContext context;

  v8::V8::IgnoreOutOfMemoryException();

  v8::Local<v8::Script> script =