Implement API functions for handling the AccessorDescriptor

test/cctest/test-api.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 6961 matching lines @@
   x->Get(v8_str("get"));
   x->Set(v8_str("set"), v8::Integer::New(8));
   x->Get(v8_str("get"));
   x->Set(v8_str("set"), v8::Integer::New(8));
   x->Get(v8_str("get"));
   x->Set(v8_str("set"), v8::Integer::New(8));
   x->Get(v8_str("get"));
 }
 
 
+THREADED_TEST(DefineAndLookupGetterSetter) {
+  v8::HandleScope handle_scope;
+  LocalContext context;
+  v8::Handle<v8::Object> global = context->Global();
+
+  CompileRun("function getter() { return 'getter'; }");
+  Local<Function> getter = Local<Function>::Cast(global->Get(v8_str("getter")));
+  CompileRun("function setter() { return 'setter'; }");
+  Local<Function> setter = Local<Function>::Cast(global->Get(v8_str("setter")));
+
+  Local<Object> obj = Object::New();
+  obj->DefineGetter(v8_str("getter"), getter);
+  obj->DefineSetter(v8_str("setter"), setter);
+  context->Global()->Set(String::New("obj"), obj);
+
+  CompileRun("d_getter = Object.getOwnPropertyDescriptor(obj, 'getter');"
+             "d_setter = Object.getOwnPropertyDescriptor(obj, 'setter');");
+
+  Local<Value> res = CompileRun("d_getter.get()");
+  String::AsciiValue string_value1(res);
+  CHECK_EQ("getter", *string_value1);
+  Local<Value> f1 = obj->LookupGetter(v8_str("getter"));
+  Local<Value> res2 = Local<Function>::Cast(f1)->Call(obj, 0, NULL);
+  String::AsciiValue string_value2(res2);
+  CHECK_EQ("getter", *string_value2);
+
+  Local<Value> res3 = CompileRun("d_getter.set");
+  CHECK(res3->IsUndefined());
+  Local<Value> res4 = obj->LookupSetter(v8_str("getter"));
+  CHECK(res4->IsUndefined());
+
+  Local<Value> res5 = CompileRun("d_setter.get");
+  CHECK(res5->IsUndefined());
+  Local<Value> res6 = obj->LookupGetter(v8_str("setter"));
+  CHECK(res6->IsUndefined());
+
+  Local<Value> res7 = CompileRun("d_setter.set()");
+  String::AsciiValue string_value3(res7);
+  CHECK_EQ("setter", *string_value3);
+  Local<Value> f2 = obj->LookupSetter(v8_str("setter"));
+  Local<Value> res8 = Local<Function>::Cast(f2)->Call(obj, 0, NULL);
+  String::AsciiValue string_value4(res8);
+  CHECK_EQ("setter", *string_value4);
+
+  CompileRun("function getter2() { return 'getter2'; }");
+  Local<Function> getter2 =
+      Local<Function>::Cast(global->Get(v8_str("getter2")));
+  obj->DefineGetter(v8_str("getter"), getter2);
+  CompileRun("d_getter = Object.getOwnPropertyDescriptor(obj, 'getter');");
+  Local<Value> res9 = CompileRun("d_getter.get()");
+  String::AsciiValue string_value5(res9);
+  CHECK_EQ("getter2", *string_value5);
+  Local<Value> f3 = obj->LookupGetter(v8_str("getter"));
+  Local<Value> res10 = Local<Function>::Cast(f3)->Call(obj, 0, NULL);
+  String::AsciiValue string_value6(res10);
+  CHECK_EQ("getter2", *string_value6);
+
+  CompileRun("function setter2() { return 'setter2'; }");
+  Local<Function> setter2 =
+      Local<Function>::Cast(global->Get(v8_str("setter2")));
+  obj->DefineSetter(v8_str("setter"), setter2);
+  CompileRun("d_setter = Object.getOwnPropertyDescriptor(obj, 'setter');");
+  Local<Value> res11 = CompileRun("d_setter.set()");
+  String::AsciiValue string_value7(res11);
+  CHECK_EQ("setter2", *string_value7);
+  Local<Value> f4 = obj->LookupSetter(v8_str("setter"));
+  Local<Value> res12 = Local<Function>::Cast(f4)->Call(obj, 0, NULL);
+  String::AsciiValue string_value8(res12);
+  CHECK_EQ("setter2", *string_value8);
+}
+
+
 THREADED_TEST(Constructor) {
   v8::HandleScope handle_scope;
   LocalContext context;
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();
   templ->SetClassName(v8_str("Fun"));
   Local<Function> cons = templ->GetFunction();
   context->Global()->Set(v8_str("Fun"), cons);
   Local<v8::Object> inst = cons->NewInstance();
   i::Handle<i::JSObject> obj = v8::Utils::OpenHandle(*inst);
   Local<Value> value = CompileRun("(new Fun()).constructor === Fun");
@@ skipping 7685 matching lines @@
   }
 
   i::Isolate::Current()->heap()->CollectAllGarbage(true);
   { i::Object* raw_map_cache = i::Isolate::Current()->context()->map_cache();
     if (raw_map_cache != i::Isolate::Current()->heap()->undefined_value()) {
       i::MapCache* map_cache = i::MapCache::cast(raw_map_cache);
       CHECK_GT(elements, map_cache->NumberOfElements());
     }
   }
 }