CSE2410 Fall 2014 Bounce

void TerminateCurrentThread(const v8::FunctionCallbackInfo<v8::Value>& args) {

}

void Loop(const v8::FunctionCallbackInfo<v8::Value>& args) {

  v8::Handle<v8::String> source =

      v8::String::New("try { doloop(); fail(); } catch(e) { fail(); }");

  v8::Handle<v8::Value> result = v8::Script::Compile(source)->Run();

  CHECK(result.IsEmpty());

}

void DoLoop(const v8::FunctionCallbackInfo<v8::Value>& args) {

  v8::TryCatch try_catch;

  v8::Script::Compile(v8::String::New("function f() {"

                                      "  var term = true;"

                                      "  try {"

  CHECK(try_catch.Exception()->IsNull());

  CHECK(try_catch.Message().IsEmpty());

  CHECK(!try_catch.CanContinue());

}

void DoLoopNoCall(const v8::FunctionCallbackInfo<v8::Value>& args) {

  v8::TryCatch try_catch;

  v8::Script::Compile(v8::String::New("var term = true;"

                                      "while(true) {"

                                      "  if (term) terminate();"

  CHECK(try_catch.Exception()->IsNull());

  CHECK(try_catch.Message().IsEmpty());

  CHECK(!try_catch.CanContinue());

}

// Test that a single thread of JavaScript execution can terminate

// itself.

TEST(TerminateOnlyV8ThreadFromThreadItself) {

  v8::Handle<v8::ObjectTemplate> global =

      CreateGlobalTemplate(TerminateCurrentThread, DoLoop);

  v8::Handle<v8::Context> context =

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

  // Run a loop that will be infinite if thread termination does not work.

  v8::Handle<v8::String> source =

      v8::String::New("try { loop(); fail(); } catch(e) { fail(); }");

  v8::Script::Compile(source)->Run();

  // Test that we can run the code again after thread termination.

  v8::Script::Compile(source)->Run();

}

// Test that a single thread of JavaScript execution can terminate

// itself in a loop that performs no calls.

TEST(TerminateOnlyV8ThreadFromThreadItselfNoLoop) {

  v8::Handle<v8::ObjectTemplate> global =

      CreateGlobalTemplate(TerminateCurrentThread, DoLoopNoCall);

  v8::Handle<v8::Context> context =

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

  // Run a loop that will be infinite if thread termination does not work.

  v8::Handle<v8::String> source =

      v8::String::New("try { loop(); fail(); } catch(e) { fail(); }");

  v8::Script::Compile(source)->Run();

  // Test that we can run the code again after thread termination.

  v8::Script::Compile(source)->Run();

}

// from the side by another thread.

TEST(TerminateOnlyV8ThreadFromOtherThread) {

  semaphore = new v8::internal::Semaphore(0);

  thread.Start();

  v8::Handle<v8::ObjectTemplate> global = CreateGlobalTemplate(Signal, DoLoop);

  v8::Handle<v8::Context> context =

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

  // Run a loop that will be infinite if thread termination does not work.

  v8::Handle<v8::String> source =

      v8::String::New("try { loop(); fail(); } catch(e) { fail(); }");

void TerminateOrReturnObject(const v8::FunctionCallbackInfo<v8::Value>& args) {

  if (++call_count == 10) {

    return;

  }

  v8::Local<v8::Object> result = v8::Object::New();

void LoopGetProperty(const v8::FunctionCallbackInfo<v8::Value>& args) {

  v8::TryCatch try_catch;

  v8::Script::Compile(v8::String::New("function f() {"

                                      "  try {"

                                      "    while(true) {"

  CHECK(try_catch.Exception()->IsNull());

  CHECK(try_catch.Message().IsEmpty());

  CHECK(!try_catch.CanContinue());

}

// Test that we correctly handle termination exceptions if they are

// triggered by the creation of error objects in connection with ICs.

TEST(TerminateLoadICException) {

  v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();

  global->Set(v8::String::New("terminate_or_return_object"),

              v8::FunctionTemplate::New(TerminateOrReturnObject));

              v8::FunctionTemplate::New(LoopGetProperty));

  v8::Handle<v8::Context> context =

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

  // Run a loop that will be infinite if thread termination does not work.

  v8::Handle<v8::String> source =

      v8::String::New("try { loop(); fail(); } catch(e) { fail(); }");

  call_count = 0;

  v8::Script::Compile(source)->Run();

  // Test that we can run the code again after thread termination.

  call_count = 0;

  v8::Script::Compile(source)->Run();

}

void ReenterAfterTermination(const v8::FunctionCallbackInfo<v8::Value>& args) {

  v8::TryCatch try_catch;

  v8::Script::Compile(v8::String::New("function f() {"

                                      "  var term = true;"

                                      "  try {"

  CHECK(try_catch.Exception()->IsNull());

  CHECK(try_catch.Message().IsEmpty());

  CHECK(!try_catch.CanContinue());

  v8::Script::Compile(v8::String::New("function f() { fail(); } f()"))->Run();

}

// Test that reentry into V8 while the termination exception is still pending

// (has not yet unwound the 0-level JS frame) does not crash.

TEST(TerminateAndReenterFromThreadItself) {

  v8::Handle<v8::ObjectTemplate> global =

      CreateGlobalTemplate(TerminateCurrentThread, ReenterAfterTermination);

  v8::Handle<v8::Context> context =

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

  CHECK(!v8::V8::IsExecutionTerminating());

  v8::Handle<v8::String> source =

      v8::String::New("try { loop(); fail(); } catch(e) { fail(); }");

  v8::Script::Compile(source)->Run();

  // Check we can run JS again after termination.

  CHECK(v8::Script::Compile(v8::String::New("function f() { return true; }"

                                            "f()"))->Run()->IsTrue());

  CHECK(!try_catch.CanContinue());

  CHECK(v8::V8::IsExecutionTerminating());

  CHECK(try_catch.HasTerminated());

  CHECK(!v8::V8::IsExecutionTerminating());

}

// Test that a single thread of JavaScript execution can terminate

// itself and then resume execution.

TEST(TerminateCancelTerminateFromThreadItself) {

  v8::HandleScope scope(isolate);

  v8::Handle<v8::ObjectTemplate> global =

      CreateGlobalTemplate(TerminateCurrentThread, DoLoopCancelTerminate);

  v8::Handle<v8::Context> context = v8::Context::New(isolate, NULL, global);

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

  v8::Handle<v8::String> source =

      v8::String::New("try { doloop(); } catch(e) { fail(); } 'completed';");

  // Check that execution completed with correct return value.