src/v8/test/cctest/test-accessors.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #include <stdlib.h>
  29
  30 #include "src/v8.h"
  31
  32 #include "src/api.h"
  33 #include "src/frames-inl.h"
  34 #include "src/string-stream.h"
  35 #include "test/cctest/cctest.h"
  36
  37 using ::v8::ObjectTemplate;
  38 using ::v8::Value;
  39 using ::v8::Context;
  40 using ::v8::Local;
  41 using ::v8::String;
  42 using ::v8::Script;
  43 using ::v8::Function;
  44 using ::v8::Extension;
  45
  46 static void handle_property(Local<String> name,
  47                             const v8::PropertyCallbackInfo<v8::Value>& info) {
  48   ApiTestFuzzer::Fuzz();
  49   info.GetReturnValue().Set(v8_num(900));
  50 }
  51
  52 static void handle_property_2(Local<String> name,
  53                               const v8::PropertyCallbackInfo<v8::Value>& info) {
  54   ApiTestFuzzer::Fuzz();
  55   info.GetReturnValue().Set(v8_num(902));
  56 }
  57
  58
  59 static void handle_property(const v8::FunctionCallbackInfo<v8::Value>& info) {
  60   ApiTestFuzzer::Fuzz();
  61   CHECK_EQ(0, info.Length());
  62   info.GetReturnValue().Set(v8_num(907));
  63 }
  64
  65
  66 THREADED_TEST(PropertyHandler) {
  67   LocalContext env;
  68   v8::Isolate* isolate = env->GetIsolate();
  69   v8::HandleScope scope(isolate);
  70   Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New(isolate);
  71   fun_templ->InstanceTemplate()->SetAccessor(v8_str("foo"), handle_property);
  72   Local<v8::FunctionTemplate> getter_templ =
  73       v8::FunctionTemplate::New(isolate, handle_property);
  74   getter_templ->SetLength(0);
  75   fun_templ->
  76       InstanceTemplate()->SetAccessorProperty(v8_str("bar"), getter_templ);
  77   fun_templ->InstanceTemplate()->
  78       SetNativeDataProperty(v8_str("instance_foo"), handle_property);
  79   fun_templ->SetNativeDataProperty(v8_str("object_foo"), handle_property_2);
  80   Local<Function> fun = fun_templ->GetFunction();
  81   env->Global()->Set(v8_str("Fun"), fun);
  82   Local<Script> getter;
  83   Local<Script> setter;
  84   // check function instance accessors
  85   getter = v8_compile("var obj = new Fun(); obj.instance_foo;");
  86   CHECK_EQ(900, getter->Run()->Int32Value());
  87   setter = v8_compile("obj.instance_foo = 901;");
  88   CHECK_EQ(901, setter->Run()->Int32Value());
  89   getter = v8_compile("obj.bar;");
  90   CHECK_EQ(907, getter->Run()->Int32Value());
  91   setter = v8_compile("obj.bar = 908;");
  92   CHECK_EQ(908, setter->Run()->Int32Value());
  93   // check function static accessors
  94   getter = v8_compile("Fun.object_foo;");
  95   CHECK_EQ(902, getter->Run()->Int32Value());
  96   setter = v8_compile("Fun.object_foo = 903;");
  97   CHECK_EQ(903, setter->Run()->Int32Value());
  98 }
  99
 100
 101 static void GetIntValue(Local<String> property,
 102                         const v8::PropertyCallbackInfo<v8::Value>& info) {
 103   ApiTestFuzzer::Fuzz();
 104   int* value =
 105       static_cast<int*>(v8::Handle<v8::External>::Cast(info.Data())->Value());
 106   info.GetReturnValue().Set(v8_num(*value));
 107 }
 108
 109
 110 static void SetIntValue(Local<String> property,
 111                         Local<Value> value,
 112                         const v8::PropertyCallbackInfo<void>& info) {
 113   int* field =
 114       static_cast<int*>(v8::Handle<v8::External>::Cast(info.Data())->Value());
 115   *field = value->Int32Value();
 116 }
 117
 118 int foo, bar, baz;
 119
 120 THREADED_TEST(GlobalVariableAccess) {
 121   foo = 0;
 122   bar = -4;
 123   baz = 10;
 124   v8::Isolate* isolate = CcTest::isolate();
 125   v8::HandleScope scope(isolate);
 126   v8::Handle<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
 127   templ->InstanceTemplate()->SetAccessor(
 128       v8_str("foo"), GetIntValue, SetIntValue,
 129       v8::External::New(isolate, &foo));
 130   templ->InstanceTemplate()->SetAccessor(
 131       v8_str("bar"), GetIntValue, SetIntValue,
 132       v8::External::New(isolate, &bar));
 133   templ->InstanceTemplate()->SetAccessor(
 134       v8_str("baz"), GetIntValue, SetIntValue,
 135       v8::External::New(isolate, &baz));
 136   LocalContext env(0, templ->InstanceTemplate());
 137   v8_compile("foo = (++bar) + baz")->Run();
 138   CHECK_EQ(bar, -3);
 139   CHECK_EQ(foo, 7);
 140 }
 141
 142
 143 static int x_register[2] = {0, 0};
 144 static v8::Handle<v8::Object> x_receiver;
 145 static v8::Handle<v8::Object> x_holder;
 146
 147 template<class Info>
 148 static void XGetter(const Info& info, int offset) {
 149   ApiTestFuzzer::Fuzz();
 150   v8::Isolate* isolate = CcTest::isolate();
 151   CHECK_EQ(isolate, info.GetIsolate());
 152   CHECK_EQ(x_receiver, info.This());
 153   info.GetReturnValue().Set(v8_num(x_register[offset]));
 154 }
 155
 156
 157 static void XGetter(Local<String> name,
 158                     const v8::PropertyCallbackInfo<v8::Value>& info) {
 159   CHECK_EQ(x_holder, info.Holder());
 160   XGetter(info, 0);
 161 }
 162
 163
 164 static void XGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
 165   CHECK_EQ(x_receiver, info.Holder());
 166   XGetter(info, 1);
 167 }
 168
 169
 170 template<class Info>
 171 static void XSetter(Local<Value> value, const Info& info, int offset) {
 172   v8::Isolate* isolate = CcTest::isolate();
 173   CHECK_EQ(isolate, info.GetIsolate());
 174   CHECK_EQ(x_holder, info.This());
 175   CHECK_EQ(x_holder, info.Holder());
 176   x_register[offset] = value->Int32Value();
 177   info.GetReturnValue().Set(v8_num(-1));
 178 }
 179
 180
 181 static void XSetter(Local<String> name,
 182                     Local<Value> value,
 183                     const v8::PropertyCallbackInfo<void>& info) {
 184   XSetter(value, info, 0);
 185 }
 186
 187
 188 static void XSetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
 189   CHECK_EQ(1, info.Length());
 190   XSetter(info[0], info, 1);
 191 }
 192
 193
 194 THREADED_TEST(AccessorIC) {
 195   LocalContext context;
 196   v8::Isolate* isolate = context->GetIsolate();
 197   v8::HandleScope scope(isolate);
 198   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 199   obj->SetAccessor(v8_str("x0"), XGetter, XSetter);
 200   obj->SetAccessorProperty(v8_str("x1"),
 201                            v8::FunctionTemplate::New(isolate, XGetter),
 202                            v8::FunctionTemplate::New(isolate, XSetter));
 203   x_holder = obj->NewInstance();
 204   context->Global()->Set(v8_str("holder"), x_holder);
 205   x_receiver = v8::Object::New(isolate);
 206   context->Global()->Set(v8_str("obj"), x_receiver);
 207   v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(CompileRun(
 208     "obj.__proto__ = holder;"
 209     "var result = [];"
 210     "var key_0 = 'x0';"
 211     "var key_1 = 'x1';"
 212     "for (var j = 0; j < 10; j++) {"
 213     "  var i = 4*j;"
 214     "  result.push(holder.x0 = i);"
 215     "  result.push(obj.x0);"
 216     "  result.push(holder.x1 = i + 1);"
 217     "  result.push(obj.x1);"
 218     "  result.push(holder[key_0] = i + 2);"
 219     "  result.push(obj[key_0]);"
 220     "  result.push(holder[key_1] = i + 3);"
 221     "  result.push(obj[key_1]);"
 222     "}"
 223     "result"));
 224   CHECK_EQ(80, array->Length());
 225   for (int i = 0; i < 80; i++) {
 226     v8::Handle<Value> entry = array->Get(v8::Integer::New(isolate, i));
 227     CHECK_EQ(v8::Integer::New(isolate, i/2), entry);
 228   }
 229 }
 230
 231
 232 template <int C>
 233 static void HandleAllocatingGetter(
 234     Local<String> name,
 235     const v8::PropertyCallbackInfo<v8::Value>& info) {
 236   ApiTestFuzzer::Fuzz();
 237   for (int i = 0; i < C; i++)
 238     v8::String::NewFromUtf8(info.GetIsolate(), "foo");
 239   info.GetReturnValue().Set(v8::String::NewFromUtf8(info.GetIsolate(), "foo"));
 240 }
 241
 242
 243 THREADED_TEST(HandleScopePop) {
 244   LocalContext context;
 245   v8::Isolate* isolate = context->GetIsolate();
 246   v8::HandleScope scope(isolate);
 247   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 248   obj->SetAccessor(v8_str("one"), HandleAllocatingGetter<1>);
 249   obj->SetAccessor(v8_str("many"), HandleAllocatingGetter<1024>);
 250   v8::Handle<v8::Object> inst = obj->NewInstance();
 251   context->Global()->Set(v8::String::NewFromUtf8(isolate, "obj"), inst);
 252   int count_before =
 253       i::HandleScope::NumberOfHandles(reinterpret_cast<i::Isolate*>(isolate));
 254   {
 255     v8::HandleScope scope(isolate);
 256     CompileRun(
 257         "for (var i = 0; i < 1000; i++) {"
 258         "  obj.one;"
 259         "  obj.many;"
 260         "}");
 261   }
 262   int count_after =
 263       i::HandleScope::NumberOfHandles(reinterpret_cast<i::Isolate*>(isolate));
 264   CHECK_EQ(count_before, count_after);
 265 }
 266
 267 static void CheckAccessorArgsCorrect(
 268     Local<String> name,
 269     const v8::PropertyCallbackInfo<v8::Value>& info) {
 270   CHECK(info.GetIsolate() == CcTest::isolate());
 271   CHECK(info.This() == info.Holder());
 272   CHECK(
 273       info.Data()->Equals(v8::String::NewFromUtf8(CcTest::isolate(), "data")));
 274   ApiTestFuzzer::Fuzz();
 275   CHECK(info.GetIsolate() == CcTest::isolate());
 276   CHECK(info.This() == info.Holder());
 277   CHECK(
 278       info.Data()->Equals(v8::String::NewFromUtf8(CcTest::isolate(), "data")));
 279   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
 280   CHECK(info.GetIsolate() == CcTest::isolate());
 281   CHECK(info.This() == info.Holder());
 282   CHECK(
 283       info.Data()->Equals(v8::String::NewFromUtf8(CcTest::isolate(), "data")));
 284   info.GetReturnValue().Set(17);
 285 }
 286
 287
 288 THREADED_TEST(DirectCall) {
 289   LocalContext context;
 290   v8::Isolate* isolate = context->GetIsolate();
 291   v8::HandleScope scope(isolate);
 292   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 293   obj->SetAccessor(v8_str("xxx"),
 294                    CheckAccessorArgsCorrect,
 295                    NULL,
 296                    v8::String::NewFromUtf8(isolate, "data"));
 297   v8::Handle<v8::Object> inst = obj->NewInstance();
 298   context->Global()->Set(v8::String::NewFromUtf8(isolate, "obj"),
 299                          inst);
 300   Local<Script> scr = v8::Script::Compile(
 301       v8::String::NewFromUtf8(isolate, "obj.xxx"));
 302   for (int i = 0; i < 10; i++) {
 303     Local<Value> result = scr->Run();
 304     CHECK(!result.IsEmpty());
 305     CHECK_EQ(17, result->Int32Value());
 306   }
 307 }
 308
 309 static void EmptyGetter(Local<String> name,
 310                         const v8::PropertyCallbackInfo<v8::Value>& info) {
 311   CheckAccessorArgsCorrect(name, info);
 312   ApiTestFuzzer::Fuzz();
 313   CheckAccessorArgsCorrect(name, info);
 314   info.GetReturnValue().Set(v8::Handle<v8::Value>());
 315 }
 316
 317
 318 THREADED_TEST(EmptyResult) {
 319   LocalContext context;
 320   v8::Isolate* isolate = context->GetIsolate();
 321   v8::HandleScope scope(isolate);
 322   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 323   obj->SetAccessor(v8_str("xxx"), EmptyGetter, NULL,
 324                    v8::String::NewFromUtf8(isolate, "data"));
 325   v8::Handle<v8::Object> inst = obj->NewInstance();
 326   context->Global()->Set(v8::String::NewFromUtf8(isolate, "obj"), inst);
 327   Local<Script> scr =
 328       v8::Script::Compile(v8::String::NewFromUtf8(isolate, "obj.xxx"));
 329   for (int i = 0; i < 10; i++) {
 330     Local<Value> result = scr->Run();
 331     CHECK(result == v8::Undefined(isolate));
 332   }
 333 }
 334
 335
 336 THREADED_TEST(NoReuseRegress) {
 337   // Check that the IC generated for the one test doesn't get reused
 338   // for the other.
 339   v8::Isolate* isolate = CcTest::isolate();
 340   v8::HandleScope scope(isolate);
 341   {
 342     v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 343     obj->SetAccessor(v8_str("xxx"), EmptyGetter, NULL,
 344                      v8::String::NewFromUtf8(isolate, "data"));
 345     LocalContext context;
 346     v8::Handle<v8::Object> inst = obj->NewInstance();
 347     context->Global()->Set(v8::String::NewFromUtf8(isolate, "obj"), inst);
 348     Local<Script> scr =
 349         v8::Script::Compile(v8::String::NewFromUtf8(isolate, "obj.xxx"));
 350     for (int i = 0; i < 2; i++) {
 351       Local<Value> result = scr->Run();
 352       CHECK(result == v8::Undefined(isolate));
 353     }
 354   }
 355   {
 356     v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 357     obj->SetAccessor(v8_str("xxx"),
 358                      CheckAccessorArgsCorrect,
 359                      NULL,
 360                      v8::String::NewFromUtf8(isolate, "data"));
 361     LocalContext context;
 362     v8::Handle<v8::Object> inst = obj->NewInstance();
 363     context->Global()->Set(v8::String::NewFromUtf8(isolate, "obj"), inst);
 364     Local<Script> scr =
 365         v8::Script::Compile(v8::String::NewFromUtf8(isolate, "obj.xxx"));
 366     for (int i = 0; i < 10; i++) {
 367       Local<Value> result = scr->Run();
 368       CHECK(!result.IsEmpty());
 369       CHECK_EQ(17, result->Int32Value());
 370     }
 371   }
 372 }
 373
 374 static void ThrowingGetAccessor(
 375     Local<String> name,
 376     const v8::PropertyCallbackInfo<v8::Value>& info) {
 377   ApiTestFuzzer::Fuzz();
 378   info.GetIsolate()->ThrowException(v8_str("g"));
 379 }
 380
 381
 382 static void ThrowingSetAccessor(Local<String> name,
 383                                 Local<Value> value,
 384                                 const v8::PropertyCallbackInfo<void>& info) {
 385   info.GetIsolate()->ThrowException(value);
 386 }
 387
 388
 389 THREADED_TEST(Regress1054726) {
 390   LocalContext env;
 391   v8::Isolate* isolate = env->GetIsolate();
 392   v8::HandleScope scope(isolate);
 393   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 394   obj->SetAccessor(v8_str("x"),
 395                    ThrowingGetAccessor,
 396                    ThrowingSetAccessor,
 397                    Local<Value>());
 398
 399   env->Global()->Set(v8_str("obj"), obj->NewInstance());
 400
 401   // Use the throwing property setter/getter in a loop to force
 402   // the accessor ICs to be initialized.
 403   v8::Handle<Value> result;
 404   result = Script::Compile(v8_str(
 405       "var result = '';"
 406       "for (var i = 0; i < 5; i++) {"
 407       "  try { obj.x; } catch (e) { result += e; }"
 408       "}; result"))->Run();
 409   CHECK_EQ(v8_str("ggggg"), result);
 410
 411   result = Script::Compile(String::NewFromUtf8(
 412       isolate,
 413       "var result = '';"
 414       "for (var i = 0; i < 5; i++) {"
 415       "  try { obj.x = i; } catch (e) { result += e; }"
 416       "}; result"))->Run();
 417   CHECK_EQ(v8_str("01234"), result);
 418 }
 419
 420
 421 static void AllocGetter(Local<String> name,
 422                         const v8::PropertyCallbackInfo<v8::Value>& info) {
 423   ApiTestFuzzer::Fuzz();
 424   info.GetReturnValue().Set(v8::Array::New(info.GetIsolate(), 1000));
 425 }
 426
 427
 428 THREADED_TEST(Gc) {
 429   LocalContext env;
 430   v8::Isolate* isolate = env->GetIsolate();
 431   v8::HandleScope scope(isolate);
 432   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 433   obj->SetAccessor(v8_str("xxx"), AllocGetter);
 434   env->Global()->Set(v8_str("obj"), obj->NewInstance());
 435   Script::Compile(String::NewFromUtf8(
 436       isolate,
 437       "var last = [];"
 438       "for (var i = 0; i < 2048; i++) {"
 439       "  var result = obj.xxx;"
 440       "  result[0] = last;"
 441       "  last = result;"
 442       "}"))->Run();
 443 }
 444
 445
 446 static void StackCheck(Local<String> name,
 447                        const v8::PropertyCallbackInfo<v8::Value>& info) {
 448   i::StackFrameIterator iter(reinterpret_cast<i::Isolate*>(info.GetIsolate()));
 449   for (int i = 0; !iter.done(); i++) {
 450     i::StackFrame* frame = iter.frame();
 451     CHECK(i != 0 || (frame->type() == i::StackFrame::EXIT));
 452     i::Code* code = frame->LookupCode();
 453     CHECK(code->IsCode());
 454     i::Address pc = frame->pc();
 455     CHECK(code->contains(pc));
 456     iter.Advance();
 457   }
 458 }
 459
 460
 461 THREADED_TEST(StackIteration) {
 462   LocalContext env;
 463   v8::Isolate* isolate = env->GetIsolate();
 464   v8::HandleScope scope(isolate);
 465   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 466   i::StringStream::ClearMentionedObjectCache(
 467       reinterpret_cast<i::Isolate*>(isolate));
 468   obj->SetAccessor(v8_str("xxx"), StackCheck);
 469   env->Global()->Set(v8_str("obj"), obj->NewInstance());
 470   Script::Compile(String::NewFromUtf8(
 471       isolate,
 472       "function foo() {"
 473       "  return obj.xxx;"
 474       "}"
 475       "for (var i = 0; i < 100; i++) {"
 476       "  foo();"
 477       "}"))->Run();
 478 }
 479
 480
 481 static void AllocateHandles(Local<String> name,
 482                             const v8::PropertyCallbackInfo<v8::Value>& info) {
 483   for (int i = 0; i < i::kHandleBlockSize + 1; i++) {
 484     v8::Local<v8::Value>::New(info.GetIsolate(), name);
 485   }
 486   info.GetReturnValue().Set(v8::Integer::New(info.GetIsolate(), 100));
 487 }
 488
 489
 490 THREADED_TEST(HandleScopeSegment) {
 491   // Check that we can return values past popping of handle scope
 492   // segments.
 493   LocalContext env;
 494   v8::Isolate* isolate = env->GetIsolate();
 495   v8::HandleScope scope(isolate);
 496   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 497   obj->SetAccessor(v8_str("xxx"), AllocateHandles);
 498   env->Global()->Set(v8_str("obj"), obj->NewInstance());
 499   v8::Handle<v8::Value> result = Script::Compile(String::NewFromUtf8(
 500       isolate,
 501       "var result;"
 502       "for (var i = 0; i < 4; i++)"
 503       "  result = obj.xxx;"
 504       "result;"))->Run();
 505   CHECK_EQ(100, result->Int32Value());
 506 }
 507
 508
 509 void JSONStringifyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info) {
 510   v8::Handle<v8::Array> array = v8::Array::New(info.GetIsolate(), 1);
 511   array->Set(0, v8_str("regress"));
 512   info.GetReturnValue().Set(array);
 513 }
 514
 515
 516 void JSONStringifyGetter(Local<String> name,
 517                          const v8::PropertyCallbackInfo<v8::Value>& info) {
 518   info.GetReturnValue().Set(v8_str("crbug-161028"));
 519 }
 520
 521
 522 THREADED_TEST(JSONStringifyNamedInterceptorObject) {
 523   LocalContext env;
 524   v8::Isolate* isolate = env->GetIsolate();
 525   v8::HandleScope scope(isolate);
 526
 527   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
 528   obj->SetNamedPropertyHandler(
 529       JSONStringifyGetter, NULL, NULL, NULL, JSONStringifyEnumerator);
 530   env->Global()->Set(v8_str("obj"), obj->NewInstance());
 531   v8::Handle<v8::String> expected = v8_str("{\"regress\":\"crbug-161028\"}");
 532   CHECK(CompileRun("JSON.stringify(obj)")->Equals(expected));
 533 }
 534
 535
 536 static v8::Local<v8::Context> expected_current_context;
 537 static v8::Local<v8::Context> expected_calling_context;
 538
 539
 540 static void check_contexts(const v8::FunctionCallbackInfo<v8::Value>& info) {
 541   ApiTestFuzzer::Fuzz();
 542   CHECK(expected_current_context == info.GetIsolate()->GetCurrentContext());
 543   CHECK(expected_calling_context == info.GetIsolate()->GetCallingContext());
 544 }
 545
 546
 547 THREADED_TEST(AccessorPropertyCrossContext) {
 548   LocalContext env;
 549   v8::Isolate* isolate = env->GetIsolate();
 550   v8::HandleScope scope(isolate);
 551   v8::Handle<v8::Function> fun = v8::Function::New(isolate, check_contexts);
 552   LocalContext switch_context;
 553   switch_context->Global()->Set(v8_str("fun"), fun);
 554   v8::TryCatch try_catch;
 555   expected_current_context = env.local();
 556   expected_calling_context = switch_context.local();
 557   CompileRun(
 558       "var o = Object.create(null, { n: { get:fun } });"
 559       "for (var i = 0; i < 10; i++) o.n;");
 560   CHECK(!try_catch.HasCaught());
 561 }
 562
 563
 564 THREADED_TEST(GlobalObjectAccessor) {
 565   LocalContext env;
 566   v8::Isolate* isolate = env->GetIsolate();
 567   v8::HandleScope scope(isolate);
 568   CompileRun(
 569       "var set_value = 1;"
 570       "Object.defineProperty(this.__proto__, 'x', {"
 571       "    get : function() { return this; },"
 572       "    set : function() { set_value = this; }"
 573       "});"
 574       "function getter() { return x; }"
 575       "function setter() { x = 1; }"
 576       "for (var i = 0; i < 4; i++) { getter(); setter(); }");
 577   CHECK(v8::Utils::OpenHandle(*CompileRun("getter()"))->IsJSGlobalProxy());
 578   CHECK(v8::Utils::OpenHandle(*CompileRun("set_value"))->IsJSGlobalProxy());
 579 }