CSE2410 Fall 2014 Bounce

TEST(ScanHTMLEndComments) {

  v8::V8::Initialize();

  // Regression test. See:

  //    http://code.google.com/p/chromium/issues/detail?id=53548

  // Parser/Scanner needs a stack limit.

  int marker;

      reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);

  for (int i = 0; tests[i]; i++) {

    v8::ScriptData* data =

    CHECK(data != NULL && !data->HasError());

    delete data;

  }

  for (int i = 0; fail_tests[i]; i++) {

    CHECK(data == NULL || data->HasError());

    delete data;

  }

TEST(Preparsing) {

  v8::HandleScope handles(isolate);

  v8::Local<v8::Context> context = v8::Context::New(isolate);

  v8::Context::Scope context_scope(context);

  int marker;

      reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);

  // Source containing functions that might be lazily compiled  and all types

  int error_source_length = i::StrLength(error_source);

  v8::ScriptData* preparse =

  CHECK(!preparse->HasError());

  bool lazy_flag = i::FLAG_lazy;

  {

  // Syntax error.

  v8::ScriptData* error_preparse =

  CHECK(error_preparse->HasError());

  i::ScriptDataImpl *pre_impl =

      reinterpret_cast<i::ScriptDataImpl*>(error_preparse);

  v8::V8::Initialize();

  int marker;

      reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);

  const char* programs[] = {

      NULL

  };

  for (int i = 0; programs[i]; i++) {

    const char* program = programs[i];

    i::Utf8ToUtf16CharacterStream stream(

        reinterpret_cast<const i::byte*>(program),

        static_cast<unsigned>(strlen(program)));

    i::CompleteParserRecorder log;

    scanner.Initialize(&stream);

    preparser.set_allow_lazy(true);

    preparser.set_allow_natives_syntax(true);

    i::ScriptDataImpl data(log.ExtractData());

    CHECK(!data.has_error());

  }

  v8::V8::Initialize();

  int marker;

      reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);

  const char* programs[] = {

      NULL

  };

  for (int i = 0; programs[i]; i++) {

    const char* program = programs[i];

    i::Utf8ToUtf16CharacterStream stream(

        reinterpret_cast<const i::byte*>(program),

        static_cast<unsigned>(strlen(program)));

    i::CompleteParserRecorder log;

    scanner.Initialize(&stream);

    // Preparser defaults to disallowing natives syntax.

    preparser.set_allow_lazy(true);

    i::ScriptDataImpl data(log.ExtractData());

    // Data contains syntax error.

    CHECK(data.has_error());

TEST(RegressChromium62639) {

  v8::V8::Initialize();

  int marker;

  isolate->stack_guard()->SetStackLimit(

TEST(Regress928) {

  v8::V8::Initialize();

  i::Factory* factory = isolate->factory();

  // Preparsing didn't consider the catch clause of a try statement

      "try { } catch (e) { var foo = function () { /* first */ } }"

      "var bar = function () { /* second */ }";

  i::Handle<i::String> source(

      factory->NewStringFromAscii(i::CStrVector(program)));

  i::GenericStringUtf16CharacterStream stream(source, 0, source->length());

  v8::V8::Initialize();

  int marker;

      reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);

  size_t kProgramSize = 1024 * 1024;

  memset(*program, '(', kProgramSize);

  program[kProgramSize] = '\0';

  i::Utf8ToUtf16CharacterStream stream(

      reinterpret_cast<const i::byte*>(*program),

      static_cast<unsigned>(kProgramSize));

  i::CompleteParserRecorder log;

  scanner.Initialize(&stream);

  preparser.set_allow_lazy(true);

}

                         unsigned end = 0) {

  if (end == 0) end = length;

  unsigned sub_length = end - start;

  i::Factory* factory = isolate->factory();

  i::HandleScope test_scope(isolate);

  i::SmartArrayPointer<i::uc16> uc16_buffer(new i::uc16[length]);

TEST(CharacterStreams) {

  v8::HandleScope handles(isolate);

  v8::Local<v8::Context> context = v8::Context::New(isolate);

  v8::Context::Scope context_scope(context);

                       i::Token::Value* expected_tokens,

                       int skip_pos = 0,  // Zero means not skipping.

                       int skip_to = 0) {

  scanner.Initialize(stream);

  int i = 0;

  i::Utf8ToUtf16CharacterStream stream(

       reinterpret_cast<const i::byte*>(re_source),

       static_cast<unsigned>(strlen(re_source)));

  scanner.Initialize(&stream);

  i::Token::Value start = scanner.peek();

    { NULL, NULL, NULL, i::EVAL_SCOPE, i::CLASSIC_MODE }

  };

  i::Factory* factory = isolate->factory();

  v8::Context::Scope context_scope(context);

  int marker;

    parser.set_allow_harmony_scoping(true);

    info.MarkAsGlobal();

    info.SetLanguageMode(source_data[i].language_mode);

    // Check scope types and positions.

    CHECK(scope->is_global_scope());

    CHECK_EQ(scope->start_position(), 0);

    CHECK_EQ(scope->end_position(), kProgramSize);

i::Handle<i::String> FormatMessage(i::ScriptDataImpl* data) {

  i::Factory* factory = isolate->factory();

  const char* message = data->BuildMessage();

  i::Handle<i::String> format = v8::Utils::OpenHandle(

  kAllowModules,

  kAllowGenerators,

  kAllowForOf,

};

}

  i::Factory* factory = isolate->factory();

  uintptr_t stack_limit = isolate->stack_guard()->real_climit();

  {

    i::Scanner scanner(isolate->unicode_cache());

    i::GenericStringUtf16CharacterStream stream(source, 0, source->length());

    scanner.Initialize(&stream);

  }

  i::ScriptDataImpl data(log.ExtractData());

    i::Handle<i::Script> script = factory->NewScript(source);

    i::CompilationInfoWithZone info(script);

    i::Parser parser(&info);

    info.MarkAsGlobal();

  }

  // Check that preparsing fails iff parsing fails.

}

  }

}

    NULL

  };

  v8::Context::Scope context_scope(context);

  int marker;

      reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);

  for (int i = 0; context_data[i][0] != NULL; ++i) {

    for (int j = 0; statement_data[j] != NULL; ++j) {

      for (int k = 0; termination_data[k] != NULL; ++k) {

            termination_data[k],

            context_data[i][1]);

        CHECK(length == kProgramSize);

      }

    }

  }

}

  // such (issue 2220).

  v8::internal::FLAG_min_preparse_length = 1;  // Force preparsing.

  v8::V8::Initialize();

  v8::Context::Scope context_scope(

  v8::TryCatch try_catch;

  const char* script =

      "\"use strict\";       \n"