CSE2410 Fall 2014 Bounce

  }                                                                  \

  THREADED_TEST(Name)

void RunWithProfiler(void (*test)()) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

THREADED_TEST(Handles) {

  Local<Context> local_env;

  {

    LocalContext env;

  CHECK(!local_env.IsEmpty());

  local_env->Enter();

  CHECK(!undef.IsEmpty());

  CHECK(undef->IsUndefined());

THREADED_TEST(IsolateOfContext) {

  CHECK(!env->InContext());

  env->Enter();

  CHECK(env->InContext());

  env->Exit();

  CHECK(!env->InContext());

}

THREADED_TEST(HulIgennem) {

  LocalContext env;

  Local<String> undef_str = undef->ToString();

  char* value = i::NewArray<char>(undef_str->Utf8Length() + 1);

  undef_str->WriteUtf8(value);

THREADED_TEST(Access) {

  LocalContext env;

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

  Local<Value> foo_before = obj->Get(v8_str("foo"));

  CHECK(foo_before->IsUndefined());

    CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource),

             source->GetExternalStringResourceBase(&encoding));

    CHECK_EQ(String::TWO_BYTE_ENCODING, encoding);

    CHECK_EQ(0, dispose_count);

  }

  CHECK_EQ(1, dispose_count);

}

    Local<Value> value = script->Run();

    CHECK(value->IsNumber());

    CHECK_EQ(7, value->Int32Value());

    CHECK_EQ(0, dispose_count);

  }

  CHECK_EQ(1, dispose_count);

}

    v8::HandleScope scope(env->GetIsolate());

    Local<String> source = String::New(two_byte_source);

    // Trigger GCs so that the newly allocated string moves to old gen.

    CHECK_EQ(source->IsExternal(), false);

    CHECK_EQ(source->IsExternalAscii(), false);

    String::Encoding encoding = String::UNKNOWN_ENCODING;

    Local<Value> value = script->Run();

    CHECK(value->IsNumber());

    CHECK_EQ(7, value->Int32Value());

    CHECK_EQ(0, dispose_count);

  }

  CHECK_EQ(1, dispose_count);

}

    v8::HandleScope scope(env->GetIsolate());

    Local<String> source = v8_str(c_source);

    // Trigger GCs so that the newly allocated string moves to old gen.

    bool success = source->MakeExternal(

        new TestAsciiResource(i::StrDup(c_source), &dispose_count));

    CHECK(success);

    Local<Value> value = script->Run();

    CHECK(value->IsNumber());

    CHECK_EQ(7, value->Int32Value());

    CHECK_EQ(0, dispose_count);

  }

  CHECK_EQ(1, dispose_count);

}

  v8::HandleScope scope(env->GetIsolate());

  // Free some space in the new space so that we can check freshness.

  uint16_t* two_byte_string = AsciiToTwoByteString("s1");

  Local<String> small_string = String::New(two_byte_string);

  // We should refuse to externalize newly created small string.

  CHECK(!small_string->CanMakeExternal());

  // Trigger GCs so that the newly allocated string moves to old gen.

  // Old space strings should be accepted.

  CHECK(small_string->CanMakeExternal());

  v8::HandleScope scope(env->GetIsolate());

  // Free some space in the new space so that we can check freshness.

  Local<String> small_string = String::New("s1");

  // We should refuse to externalize newly created small string.

  CHECK(!small_string->CanMakeExternal());

  // Trigger GCs so that the newly allocated string moves to old gen.

  // Old space strings should be accepted.

  CHECK(small_string->CanMakeExternal());

      "slice('abcdefghijklmnopqrstuvwxyz');"));

  // Trigger GCs so that the newly allocated string moves to old gen.

  // Turn into external string with unaligned resource data.

  int dispose_count = 0;

  CHECK(success);

  // Trigger GCs and force evacuation.

}

THREADED_TEST(UsingExternalString) {

  {

    uint16_t* two_byte_string = AsciiToTwoByteString("test string");

    Local<String> string =

        String::NewExternal(new TestResource(two_byte_string));

    i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);

    // Trigger GCs so that the newly allocated string moves to old gen.

    i::Handle<i::String> isymbol =

        factory->InternalizedStringFromString(istring);

    CHECK(isymbol->IsInternalizedString());

  }

}

THREADED_TEST(UsingExternalAsciiString) {

  {

    const char* one_byte_string = "test string";

    Local<String> string = String::NewExternal(

        new TestAsciiResource(i::StrDup(one_byte_string)));

    i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);

    // Trigger GCs so that the newly allocated string moves to old gen.

    i::Handle<i::String> isymbol =

        factory->InternalizedStringFromString(istring);

    CHECK(isymbol->IsInternalizedString());

  }

}

  int dispose_count = 0;

  bool in_new_space = false;

  {

    uint16_t* two_byte_string = AsciiToTwoByteString("test string");

    Local<String> string =

      String::NewExternal(new TestResource(two_byte_string,

                                           &dispose_count));

    i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);

    CHECK_EQ(0, dispose_count);

  }

  CHECK_EQ(1, dispose_count);

}

  int dispose_count = 0;

  bool in_new_space = false;

  {

    const char* one_byte_string = "test string";

    Local<String> string = String::NewExternal(

        new TestAsciiResource(i::StrDup(one_byte_string), &dispose_count));

    i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);

    CHECK_EQ(0, dispose_count);

  }

  CHECK_EQ(1, dispose_count);

}

    Local<Value> value = script->Run();

    CHECK(value->IsNumber());

    CHECK_EQ(7, value->Int32Value());

    CHECK_EQ(0, TestAsciiResourceWithDisposeControl::dispose_count);

  }

  CHECK_EQ(1, TestAsciiResourceWithDisposeControl::dispose_calls);

  CHECK_EQ(0, TestAsciiResourceWithDisposeControl::dispose_count);

    Local<Value> value = script->Run();

    CHECK(value->IsNumber());

    CHECK_EQ(7, value->Int32Value());

    CHECK_EQ(0, TestAsciiResourceWithDisposeControl::dispose_count);

  }

  CHECK_EQ(1, TestAsciiResourceWithDisposeControl::dispose_calls);

  CHECK_EQ(1, TestAsciiResourceWithDisposeControl::dispose_count);

}

    CHECK(value->IsNumber());

    CHECK_EQ(68, value->Int32Value());

  }

}

static void CheckReturnValue(const T& t, i::Address callback) {

  v8::ReturnValue<v8::Value> rv = t.GetReturnValue();

  i::Object** o = *reinterpret_cast<i::Object***>(&rv);

  CHECK_EQ(t.GetIsolate(), rv.GetIsolate());

  CHECK((*o)->IsTheHole() || (*o)->IsUndefined());

  // Verify reset

THREADED_PROFILED_TEST(FastReturnValues) {

  LocalContext env;

  v8::Handle<v8::Value> value;

  // check int32_t and uint32_t

  int32_t int_values[] = {

THREADED_TEST(TinyInteger) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  int32_t value = 239;

  Local<v8::Integer> value_obj = v8::Integer::New(value);

THREADED_TEST(BigSmiInteger) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  int32_t value = i::Smi::kMaxValue;

  // We cannot add one to a Smi::kMaxValue without wrapping.

THREADED_TEST(BigInteger) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  // We cannot add one to a Smi::kMaxValue without wrapping.

  if (i::SmiValuesAre31Bits()) {

THREADED_TEST(TinyUnsignedInteger) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  uint32_t value = 239;

THREADED_TEST(BigUnsignedSmiInteger) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  uint32_t value = static_cast<uint32_t>(i::Smi::kMaxValue);

  CHECK(i::Smi::IsValid(value));

THREADED_TEST(BigUnsignedInteger) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  uint32_t value = static_cast<uint32_t>(i::Smi::kMaxValue) + 1;

  CHECK(value > static_cast<uint32_t>(i::Smi::kMaxValue));

THREADED_TEST(OutOfSignedRangeUnsignedInteger) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  uint32_t INT32_MAX_AS_UINT = (1U << 31) - 1;

  uint32_t value = INT32_MAX_AS_UINT + 1;

THREADED_TEST(ToNumber) {

  LocalContext env;

  Local<String> str = v8_str("3.1415926");

  CHECK_EQ(3.1415926, str->NumberValue());

  CHECK_EQ(1.0, t->NumberValue());

  CHECK_EQ(0.0, f->NumberValue());

}

THREADED_TEST(Boolean) {

  LocalContext env;

  v8::HandleScope scope(env->GetIsolate());

  CHECK(t->Value());

  CHECK(!f->Value());

  CHECK(!u->BooleanValue());

  CHECK(!n->BooleanValue());

  v8::Handle<String> str1 = v8_str("");

  CHECK(!str1->BooleanValue());

THREADED_TEST(GlobalPrototype) {

  v8::Handle<v8::FunctionTemplate> func_templ = v8::FunctionTemplate::New();

  func_templ->PrototypeTemplate()->Set(

      "dummy",

THREADED_TEST(ObjectTemplate) {

  Local<ObjectTemplate> templ1 = ObjectTemplate::New();

  templ1->Set("x", v8_num(10));

  templ1->Set("y", v8_num(13));

THREADED_TEST(DescriptorInheritance) {

  v8::Handle<v8::FunctionTemplate> super = v8::FunctionTemplate::New();

  super->PrototypeTemplate()->Set("flabby",

                                  v8::FunctionTemplate::New(GetFlabby));

THREADED_TEST(EmptyInterceptorDoesNotShadowAccessors) {

  Handle<FunctionTemplate> parent = FunctionTemplate::New();

  Handle<FunctionTemplate> child = FunctionTemplate::New();

  child->Inherit(parent);

THREADED_TEST(EmptyInterceptorDoesNotShadowJSAccessors) {

  Handle<FunctionTemplate> parent = FunctionTemplate::New();

  Handle<FunctionTemplate> child = FunctionTemplate::New();

  child->Inherit(parent);

THREADED_TEST(EmptyInterceptorDoesNotAffectJSProperties) {

  Handle<FunctionTemplate> parent = FunctionTemplate::New();

  Handle<FunctionTemplate> child = FunctionTemplate::New();

  child->Inherit(parent);

THREADED_TEST(SwitchFromInterceptorToAccessor) {

  Handle<FunctionTemplate> templ = FunctionTemplate::New();

  AddAccessor(templ, v8_str("age"),

              SimpleAccessorGetter, SimpleAccessorSetter);

THREADED_TEST(SwitchFromAccessorToInterceptor) {

  Handle<FunctionTemplate> templ = FunctionTemplate::New();

  AddAccessor(templ, v8_str("age"),

              SimpleAccessorGetter, SimpleAccessorSetter);

THREADED_TEST(SwitchFromInterceptorToAccessorWithInheritance) {

  Handle<FunctionTemplate> parent = FunctionTemplate::New();

  Handle<FunctionTemplate> child = FunctionTemplate::New();

  child->Inherit(parent);

THREADED_TEST(SwitchFromAccessorToInterceptorWithInheritance) {

  Handle<FunctionTemplate> parent = FunctionTemplate::New();

  Handle<FunctionTemplate> child = FunctionTemplate::New();

  child->Inherit(parent);

THREADED_TEST(SwitchFromInterceptorToJSAccessor) {

  Handle<FunctionTemplate> templ = FunctionTemplate::New();

  AddInterceptor(templ, InterceptorGetter, InterceptorSetter);

  LocalContext env;

THREADED_TEST(SwitchFromJSAccessorToInterceptor) {

  Handle<FunctionTemplate> templ = FunctionTemplate::New();

  AddInterceptor(templ, InterceptorGetter, InterceptorSetter);

  LocalContext env;

THREADED_TEST(SwitchFromInterceptorToProperty) {

  Handle<FunctionTemplate> parent = FunctionTemplate::New();

  Handle<FunctionTemplate> child = FunctionTemplate::New();

  child->Inherit(parent);

THREADED_TEST(SwitchFromPropertyToInterceptor) {

  Handle<FunctionTemplate> parent = FunctionTemplate::New();

  Handle<FunctionTemplate> child = FunctionTemplate::New();

  child->Inherit(parent);

THREADED_TEST(NamedPropertyHandlerGetter) {

  echo_named_call_count = 0;

  v8::Handle<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();

  templ->InstanceTemplate()->SetNamedPropertyHandler(EchoNamedProperty,

                                                     0, 0, 0, 0,

THREADED_TEST(IndexedPropertyHandlerGetter) {

  v8::Handle<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();

  templ->InstanceTemplate()->SetIndexedPropertyHandler(EchoIndexedProperty,

                                                       0, 0, 0, 0,

THREADED_TEST(PrePropertyHandler) {

  v8::Handle<v8::FunctionTemplate> desc = v8::FunctionTemplate::New();

  desc->InstanceTemplate()->SetNamedPropertyHandler(PrePropertyHandlerGet,

                                                    0,

THREADED_TEST(DeepCrossLanguageRecursion) {

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

  global->Set(v8_str("callScriptRecursively"),

              v8::FunctionTemplate::New(CallScriptRecursivelyCall));

    Local<String> key,

    const v8::PropertyCallbackInfo<v8::Value>& info) {

  ApiTestFuzzer::Fuzz();

}

    Local<String> key,

    Local<Value>,

    const v8::PropertyCallbackInfo<v8::Value>& info) {

  info.GetReturnValue().SetUndefined();  // not the same as empty handle

}

THREADED_TEST(CallbackExceptionRegression) {

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

  obj->SetNamedPropertyHandler(ThrowingPropertyHandlerGet,

                               ThrowingPropertyHandlerSet);

THREADED_TEST(FunctionPrototype) {

  Local<v8::FunctionTemplate> Foo = v8::FunctionTemplate::New();

  Foo->PrototypeTemplate()->Set(v8_str("plak"), v8_num(321));

  LocalContext env;

THREADED_TEST(GlobalObjectInternalFields) {

  Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();

  global_template->SetInternalFieldCount(1);

  LocalContext env(NULL, global_template);

THREADED_TEST(GlobalObjectHasRealIndexedProperty) {

  LocalContext env;

  v8::Local<v8::Object> global = env->Global();

  global->Set(0, v8::String::New("value"));

                                               void* value) {

  CHECK_EQ(0, static_cast<int>(reinterpret_cast<uintptr_t>(value) & 0x1));

  obj->SetAlignedPointerInInternalField(0, value);

  CHECK_EQ(value, obj->GetAlignedPointerFromInternalField(0));

}

                                              void* value) {

  CHECK_EQ(0, static_cast<int>(reinterpret_cast<uintptr_t>(value) & 0x1));

  (*env)->SetAlignedPointerInEmbedderData(index, value);

  CHECK_EQ(value, (*env)->GetAlignedPointerFromEmbedderData(index));

}

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

    env->SetAlignedPointerInEmbedderData(i, AlignedTestPointer(i));

  }

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

    CHECK_EQ(AlignedTestPointer(i), env->GetAlignedPointerFromEmbedderData(i));

  }

  // Ensure that the test starts with an fresh heap to test whether the hash

  // code is based on the address.

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

  int hash = obj->GetIdentityHash();

  int hash1 = obj->GetIdentityHash();

  // objects should not be assigned the same hash code. If the test below fails

  // the random number generator should be evaluated.

  CHECK_NE(hash, hash2);

  int hash3 = v8::Object::New()->GetIdentityHash();

  // Make sure that the identity hash is not based on the initial address of

  // the object alone. If the test below fails the random number generator

  v8::Local<v8::Symbol> sym1 = v8::Symbol::New(isolate);

  v8::Local<v8::Symbol> sym2 = v8::Symbol::New(isolate, "my-symbol");

  // Check basic symbol functionality.

  CHECK(sym1->IsSymbol());

  CHECK_EQ(1, obj->GetOwnPropertyNames()->Length());

  CHECK_EQ(num_props + 1, obj->GetPropertyNames()->Length());

  // Add another property and delete it afterwards to force the object in

  // slow case.

  CheckInternalFieldsAreZero(ab);

  CHECK_EQ(1024, static_cast<int>(ab->ByteLength()));

  CHECK(!ab->IsExternal());

  ScopedArrayBufferContents ab_contents(ab->Externalize());

  CHECK(ab->IsExternal());

  v8::Local<v8::String> empty = v8_str("");

  v8::Local<v8::String> prop_name = v8_str("prop_name");

  // Make sure delete of a non-existent hidden value works

  CHECK(obj->DeleteHiddenValue(key));

  CHECK(obj->SetHiddenValue(key, v8::Integer::New(2002)));

  CHECK_EQ(2002, obj->GetHiddenValue(key)->Int32Value());

  // Make sure we do not find the hidden property.

  CHECK(!obj->Has(empty));

  CHECK_EQ(2002, obj->GetHiddenValue(key)->Int32Value());

  CHECK_EQ(2003, obj->Get(empty)->Int32Value());

  // Add another property and delete it afterwards to force the object in

  // slow case.

  CHECK(obj->Delete(prop_name));

  CHECK_EQ(2002, obj->GetHiddenValue(key)->Int32Value());

  CHECK(obj->SetHiddenValue(key, Handle<Value>()));

  CHECK(obj->GetHiddenValue(key).IsEmpty());

THREADED_TEST(External) {

  int x = 3;

  Local<v8::External> ext = v8::External::New(&x);

  LocalContext env;

THREADED_TEST(GlobalHandle) {

  v8::Persistent<String> global;

  {

    v8::HandleScope scope(isolate);

THREADED_TEST(ResettingGlobalHandle) {

  v8::Persistent<String> global;

  {

    v8::HandleScope scope(isolate);

THREADED_TEST(ResettingGlobalHandleToEmpty) {

  v8::Persistent<String> global;

  {

    v8::HandleScope scope(isolate);

THREADED_TEST(ClearAndLeakGlobal) {

  v8::internal::GlobalHandles* global_handles = NULL;

  int initial_handle_count = 0;

  v8::Persistent<String> global;

THREADED_TEST(GlobalHandleUpcast) {

  v8::HandleScope scope(isolate);

  v8::Persistent<String> global_string(isolate, local);

  v8::Persistent<Value>& global_value =

      v8::Persistent<Value>::Cast(global_string);

THREADED_TEST(HandleEquality) {

  v8::Persistent<String> global1;

  v8::Persistent<String> global2;

  {

THREADED_TEST(LocalHandle) {

  CHECK_EQ(local->Length(), 3);

}

};

static void WeakPointerCallback(v8::Isolate* isolate,

                                WeakCallCounter* counter) {

  CHECK_EQ(1234, counter->id());

  counter->increment();

}

  return UniqueId(reinterpret_cast<uintptr_t>(*v8::Utils::OpenPersistent(p)));

}

}

THREADED_TEST(ApiObjectGroupsCycle) {

  LocalContext env;

  v8::Isolate* iso = env->GetIsolate();

THREADED_TEST(MessageHandler0) {

  message_received = false;

  CHECK(!message_received);

  v8::V8::AddMessageListener(check_message_0, v8_num(5.76));

  LocalContext context;

TEST(MessageHandler1) {

  message_received = false;

  CHECK(!message_received);

  v8::V8::AddMessageListener(check_message_1);

  LocalContext context;

TEST(MessageHandler2) {

  message_received = false;

  CHECK(!message_received);

  v8::V8::AddMessageListener(check_message_2);

  LocalContext context;

TEST(MessageHandler3) {

  message_received = false;

  CHECK(!message_received);

  v8::V8::AddMessageListener(check_message_3);

  LocalContext context;

  v8::ScriptOrigin origin =

      v8::ScriptOrigin(v8_str("6.75"),

  v8::Handle<v8::Script> script = Script::Compile(v8_str("throw 'error'"),

                                                  &origin);

  script->Run();

TEST(MessageHandler4) {

  message_received = false;

  CHECK(!message_received);

  v8::V8::AddMessageListener(check_message_4);

  LocalContext context;

  v8::ScriptOrigin origin =

      v8::ScriptOrigin(v8_str("6.75"),

  v8::Handle<v8::Script> script = Script::Compile(v8_str("throw 'error'"),

                                                  &origin);

  script->Run();

TEST(MessageHandler5) {

  message_received = false;

  CHECK(!message_received);

  v8::V8::AddMessageListener(check_message_5a);

  LocalContext context;

  v8::ScriptOrigin origin =

      v8::ScriptOrigin(v8_str("6.75"),

  v8::Handle<v8::Script> script = Script::Compile(v8_str("throw 'error'"),

                                                  &origin);

  script->Run();

  v8::V8::AddMessageListener(check_message_5b);

  origin =

      v8::ScriptOrigin(v8_str("6.75"),

  script = Script::Compile(v8_str("throw 'error'"),

                           &origin);

  script->Run();

THREADED_TEST(Vector) {

  Local<ObjectTemplate> global = ObjectTemplate::New();

  global->Set(v8_str("f"), v8::FunctionTemplate::New(HandleF));

  LocalContext context(0, global);

THREADED_TEST(FunctionCall) {

  LocalContext context;

  CompileRun(

    "function Foo() {"

    "  var result = [];"

    "    result.push(arguments[i]);"

    "  }"

    "  return result;"

    "}");

  Local<Function> Foo =

      Local<Function>::Cast(context->Global()->Get(v8_str("Foo")));

  v8::Handle<Value>* args0 = NULL;

  Local<v8::Array> a0 = Local<v8::Array>::Cast(Foo->Call(Foo, 0, args0));

  CHECK_EQ(8.8, a4->Get(v8::Integer::New(1))->NumberValue());

  CHECK_EQ(9.9, a4->Get(v8::Integer::New(2))->NumberValue());

  CHECK_EQ(10.11, a4->Get(v8::Integer::New(3))->NumberValue());

}

  constraints.set_max_old_space_size(5 * K * K);

  v8::SetResourceConstraints(&constraints);

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->Set(v8_str("ProvokeOutOfMemory"),

             v8::FunctionTemplate::New(ProvokeOutOfMemory));

THREADED_TEST(ConversionException) {

  LocalContext env;

  CompileRun(

    "function TestClass() { };"

    "TestClass.prototype.toString = function () { throw 'uncle?'; };"

  CHECK(to_int32_result.IsEmpty());

  CheckUncle(&try_catch);

  CHECK(to_object_result.IsEmpty());

  CHECK(try_catch.HasCaught());

  try_catch.Reset();

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

  ApiTestFuzzer::Fuzz();

}

THREADED_TEST(APICatch) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->Set(v8_str("ThrowFromC"),

             v8::FunctionTemplate::New(ThrowFromC));

THREADED_TEST(APIThrowTryCatch) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->Set(v8_str("ThrowFromC"),

             v8::FunctionTemplate::New(ThrowFromC));

// JS stack.  This test therefore fails on the simulator.  The test is

// not threaded to allow the threading tests to run on the simulator.

TEST(TryCatchInTryFinally) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->Set(v8_str("CCatcher"),

             v8::FunctionTemplate::New(CCatcher));

// formatting. However, they are invoked when performing normal error

// string conversions.

TEST(APIThrowMessageOverwrittenToString) {

  v8::V8::AddMessageListener(check_reference_error_message);

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->Set(v8_str("fail"), v8::FunctionTemplate::New(Fail));

TEST(APIThrowMessage) {

  message_received = false;

  v8::V8::AddMessageListener(receive_message);

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->Set(v8_str("ThrowFromC"),

TEST(APIThrowMessageAndVerboseTryCatch) {

  message_received = false;

  v8::V8::AddMessageListener(receive_message);

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->Set(v8_str("ThrowFromC"),

THREADED_TEST(ExternalScriptException) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->Set(v8_str("ThrowFromC"),

             v8::FunctionTemplate::New(ThrowFromC));

  int count = args[0]->Int32Value();

  int cInterval = args[2]->Int32Value();

  if (count == 0) {

    return;

  } else {

    Local<Value> fun = global->Get(v8_str("JSThrowCountDown"));

    v8::Handle<Value> argv[] = { v8_num(count - 1),

                                 args[1],

      if (try_catch.HasCaught()) {

        CHECK_EQ(expected, count);

        CHECK(result.IsEmpty());

      } else {

        CHECK_NE(expected, count);

      }

// JS stack.  This test therefore fails on the simulator.  The test is

// not threaded to allow the threading tests to run on the simulator.

TEST(ExceptionOrder) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->Set(v8_str("check"), v8::FunctionTemplate::New(JSCheck));

  templ->Set(v8_str("CThrowCountDown"),

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

  ApiTestFuzzer::Fuzz();

  CHECK_EQ(1, args.Length());

}

THREADED_TEST(ThrowValues) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->Set(v8_str("Throw"), v8::FunctionTemplate::New(ThrowValue));

  LocalContext context(0, templ);

    CHECK(try_catch.HasCaught());

    try_catch.ReThrow();

  } else {

  }

}

// This exercises the ability of TryCatch.ReThrow() to restore the

// inner pending Message before throwing the exception again.

TEST(TryCatchMixedNesting) {

  v8::V8::Initialize();

  v8::TryCatch try_catch;

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  CHECK(!v8_str("5")->StrictEquals(v8_num(5)));

  CHECK(v8_num(1)->StrictEquals(v8_num(1)));

  CHECK(!v8_num(1)->StrictEquals(v8_num(2)));

  Local<Value> not_a_number = v8_num(i::OS::nan_value());

  CHECK(!not_a_number->StrictEquals(not_a_number));

  v8::Handle<v8::Object> obj = v8::Object::New();

  v8::Persistent<v8::Object> alias(isolate, obj);

  CHECK(v8::Local<v8::Object>::New(isolate, alias)->StrictEquals(obj));

  alias.Dispose();

}

THREADED_TEST(DefinePropertyOnDefineGetterSetter) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut"));

  LocalContext context;

THREADED_TEST(DefineAPIAccessorOnObject) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  LocalContext context;

THREADED_TEST(DontDeleteAPIAccessorsCannotBeOverriden) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  LocalContext context;

THREADED_TEST(ElementAPIAccessor) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  LocalContext context;

THREADED_TEST(SimplePropertyWrite) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->SetAccessor(v8_str("x"), GetXValue, SetXValue, v8_str("donut"));

  LocalContext context;

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

    CHECK(xValue.IsEmpty());

    script->Run();

    xValue.Dispose();

    xValue.Clear();

  }

THREADED_TEST(SetterOnly) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->SetAccessor(v8_str("x"), NULL, SetXValue, v8_str("donut"));

  LocalContext context;

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

    CHECK(xValue.IsEmpty());

    script->Run();

    xValue.Dispose();

    xValue.Clear();

  }

THREADED_TEST(NoAccessors) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->SetAccessor(v8_str("x"),

                     static_cast<v8::AccessorGetterCallback>(NULL),

THREADED_TEST(NamedInterceptorPropertyRead) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->SetNamedPropertyHandler(XPropertyGetter);

  LocalContext context;

THREADED_TEST(NamedInterceptorDictionaryIC) {

  Local<ObjectTemplate> templ = ObjectTemplate::New();

  templ->SetNamedPropertyHandler(XPropertyGetter);

  LocalContext context;

THREADED_TEST(NamedInterceptorDictionaryICMultipleContext) {

  v8::HandleScope scope(isolate);

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

// This is a regression test for http://crbug.com/20104. Map

// transitions should not interfere with post interceptor lookup.

THREADED_TEST(NamedInterceptorMapTransitionRead) {