v8/test/cctest/test-declarative-accessors.cc
2013-09-19 08:54:58 +00:00

301 lines
11 KiB
C++

// Copyright 2013 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
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <stdlib.h>
#include "v8.h"
#include "cctest.h"
using namespace v8::internal;
class HandleArray : public Malloced {
public:
static const unsigned kArraySize = 200;
explicit HandleArray() {}
~HandleArray() { Reset(); }
void Reset() {
for (unsigned i = 0; i < kArraySize; i++) {
if (handles_[i].IsEmpty()) continue;
handles_[i].Dispose();
handles_[i].Clear();
}
}
v8::Persistent<v8::Value> handles_[kArraySize];
private:
DISALLOW_COPY_AND_ASSIGN(HandleArray);
};
// An aligned character array of size 1024.
class AlignedArray : public Malloced {
public:
static const unsigned kArraySize = 1024/sizeof(uint64_t);
AlignedArray() { Reset(); }
void Reset() {
for (unsigned i = 0; i < kArraySize; i++) {
data_[i] = 0;
}
}
template<typename T>
T As() { return reinterpret_cast<T>(data_); }
private:
uint64_t data_[kArraySize];
DISALLOW_COPY_AND_ASSIGN(AlignedArray);
};
class DescriptorTestHelper {
public:
DescriptorTestHelper() :
isolate_(NULL), array_(new AlignedArray), handle_array_(new HandleArray) {
v8::V8::Initialize();
isolate_ = CcTest::isolate();
}
v8::Isolate* isolate_;
// Data objects.
SmartPointer<AlignedArray> array_;
SmartPointer<HandleArray> handle_array_;
private:
DISALLOW_COPY_AND_ASSIGN(DescriptorTestHelper);
};
static v8::Local<v8::ObjectTemplate> CreateConstructor(
v8::Handle<v8::Context> context,
const char* class_name,
int internal_field,
const char* descriptor_name = NULL,
v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
v8::Handle<v8::DeclaredAccessorDescriptor>()) {
v8::Local<v8::FunctionTemplate> constructor = v8::FunctionTemplate::New();
v8::Local<v8::ObjectTemplate> obj_template = constructor->InstanceTemplate();
// Setup object template.
if (descriptor_name != NULL && !descriptor.IsEmpty()) {
bool added_accessor =
obj_template->SetDeclaredAccessor(v8_str(descriptor_name), descriptor);
CHECK(added_accessor);
}
obj_template->SetInternalFieldCount((internal_field+1)*2 + 7);
context->Global()->Set(v8_str(class_name), constructor->GetFunction());
return obj_template;
}
static void VerifyRead(v8::Handle<v8::DeclaredAccessorDescriptor> descriptor,
int internal_field,
void* internal_object,
v8::Handle<v8::Value> expected_value) {
LocalContext local_context;
v8::HandleScope scope(local_context->GetIsolate());
v8::Handle<v8::Context> context = local_context.local();
CreateConstructor(context, "Accessible", internal_field, "x", descriptor);
// Setup object.
CompileRun("var accessible = new Accessible();");
v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(
context->Global()->Get(v8_str("accessible")));
obj->SetAlignedPointerInInternalField(internal_field, internal_object);
bool added_accessor;
added_accessor = obj->SetDeclaredAccessor(v8_str("y"), descriptor);
CHECK(added_accessor);
added_accessor = obj->SetDeclaredAccessor(v8_str("13"), descriptor);
CHECK(added_accessor);
// Test access from template getter.
v8::Local<v8::Value> value;
value = CompileRun("accessible.x;");
CHECK_EQ(expected_value, value);
value = CompileRun("accessible['x'];");
CHECK_EQ(expected_value, value);
// Test access from object getter.
value = CompileRun("accessible.y;");
CHECK_EQ(expected_value, value);
value = CompileRun("accessible['y'];");
CHECK_EQ(expected_value, value);
value = CompileRun("accessible[13];");
CHECK_EQ(expected_value, value);
value = CompileRun("accessible['13'];");
CHECK_EQ(expected_value, value);
}
static v8::Handle<v8::Value> Convert(int32_t value, v8::Isolate* isolate) {
return v8::Integer::New(value, isolate);
}
static v8::Handle<v8::Value> Convert(float value, v8::Isolate*) {
return v8::Number::New(value);
}
static v8::Handle<v8::Value> Convert(double value, v8::Isolate*) {
return v8::Number::New(value);
}
typedef v8::ObjectOperationDescriptor OOD;
template<typename T>
static void TestPrimitiveValue(
T value,
v8::DeclaredAccessorDescriptorDataType data_type,
DescriptorTestHelper* helper) {
v8::HandleScope handle_scope(helper->isolate_);
int index = 17;
int internal_field = 6;
v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
OOD::NewInternalFieldDereference(helper->isolate_, internal_field)
->NewRawShift(helper->isolate_, static_cast<uint16_t>(index*sizeof(T)))
->NewPrimitiveValue(helper->isolate_, data_type, 0);
v8::Handle<v8::Value> expected = Convert(value, helper->isolate_);
helper->array_->Reset();
helper->array_->As<T*>()[index] = value;
VerifyRead(descriptor, internal_field, *helper->array_, expected);
}
TEST(PrimitiveValueRead) {
DescriptorTestHelper helper;
TestPrimitiveValue<int32_t>(203, v8::kDescriptorInt32Type, &helper);
TestPrimitiveValue<float>(23.7f, v8::kDescriptorFloatType, &helper);
TestPrimitiveValue<double>(23.7, v8::kDescriptorDoubleType, &helper);
}
template<typename T>
static void TestBitmaskCompare(T bitmask,
T compare_value,
DescriptorTestHelper* helper) {
v8::HandleScope handle_scope(helper->isolate_);
int index = 13;
int internal_field = 4;
v8::Handle<v8::RawOperationDescriptor> raw_descriptor =
OOD::NewInternalFieldDereference(helper->isolate_, internal_field)
->NewRawShift(helper->isolate_, static_cast<uint16_t>(index*sizeof(T)));
v8::Handle<v8::DeclaredAccessorDescriptor> descriptor;
switch (sizeof(T)) {
case 1:
descriptor = raw_descriptor->NewBitmaskCompare8(
helper->isolate_,
static_cast<uint8_t>(bitmask),
static_cast<uint8_t>(compare_value));
break;
case 2:
descriptor = raw_descriptor->NewBitmaskCompare16(
helper->isolate_,
static_cast<uint16_t>(bitmask),
static_cast<uint16_t>(compare_value));
break;
case 4:
descriptor = raw_descriptor->NewBitmaskCompare32(
helper->isolate_,
static_cast<uint32_t>(bitmask),
static_cast<uint32_t>(compare_value));
break;
default:
CHECK(false);
break;
}
AlignedArray* array = *helper->array_;
array->Reset();
VerifyRead(descriptor, internal_field, array, v8::False(helper->isolate_));
array->As<T*>()[index] = compare_value;
VerifyRead(descriptor, internal_field, array, v8::True(helper->isolate_));
helper->array_->As<T*>()[index] = compare_value & bitmask;
VerifyRead(descriptor, internal_field, array, v8::True(helper->isolate_));
}
TEST(BitmaskCompareRead) {
DescriptorTestHelper helper;
TestBitmaskCompare<uint8_t>(0xf3, 0xa8, &helper);
TestBitmaskCompare<uint16_t>(0xfefe, 0x7d42, &helper);
TestBitmaskCompare<uint32_t>(0xfefeab18, 0x1234fdec, &helper);
}
TEST(PointerCompareRead) {
DescriptorTestHelper helper;
v8::HandleScope handle_scope(helper.isolate_);
int index = 35;
int internal_field = 3;
void* ptr = helper.isolate_;
v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
OOD::NewInternalFieldDereference(helper.isolate_, internal_field)
->NewRawShift(helper.isolate_, static_cast<uint16_t>(index*sizeof(ptr)))
->NewPointerCompare(helper.isolate_, ptr);
AlignedArray* array = *helper.array_;
VerifyRead(descriptor, internal_field, array, v8::False(helper.isolate_));
array->As<uintptr_t*>()[index] = reinterpret_cast<uintptr_t>(ptr);
VerifyRead(descriptor, internal_field, array, v8::True(helper.isolate_));
}
TEST(PointerDereferenceRead) {
DescriptorTestHelper helper;
v8::HandleScope handle_scope(helper.isolate_);
int first_index = 13;
int internal_field = 7;
int second_index = 11;
int pointed_to_index = 75;
uint16_t expected = 0x1425;
v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
OOD::NewInternalFieldDereference(helper.isolate_, internal_field)
->NewRawShift(helper.isolate_, first_index*kPointerSize)
->NewRawDereference(helper.isolate_)
->NewRawShift(helper.isolate_,
static_cast<uint16_t>(second_index*sizeof(int16_t)))
->NewPrimitiveValue(helper.isolate_, v8::kDescriptorInt16Type, 0);
AlignedArray* array = *helper.array_;
array->As<uintptr_t**>()[first_index] =
&array->As<uintptr_t*>()[pointed_to_index];
VerifyRead(descriptor, internal_field, array, v8::Integer::New(0));
second_index += pointed_to_index*sizeof(uintptr_t)/sizeof(uint16_t);
array->As<uint16_t*>()[second_index] = expected;
VerifyRead(descriptor, internal_field, array, v8::Integer::New(expected));
}
TEST(HandleDereferenceRead) {
DescriptorTestHelper helper;
v8::HandleScope handle_scope(helper.isolate_);
int index = 13;
int internal_field = 0;
v8::Handle<v8::DeclaredAccessorDescriptor> descriptor =
OOD::NewInternalFieldDereference(helper.isolate_, internal_field)
->NewRawShift(helper.isolate_, index*kPointerSize)
->NewHandleDereference(helper.isolate_);
HandleArray* array = *helper.handle_array_;
v8::Handle<v8::String> expected = v8_str("whatever");
array->handles_[index].Reset(helper.isolate_, expected);
VerifyRead(descriptor, internal_field, array, expected);
}