diff options
author | Allan Sandfeld Jensen <allan.jensen@qt.io> | 2017-07-17 13:57:45 +0200 |
---|---|---|
committer | Allan Sandfeld Jensen <allan.jensen@qt.io> | 2017-07-19 13:44:40 +0000 |
commit | 6ec7b8da05d21a3878bd21c691b41e675d74bb1c (patch) | |
tree | b87f250bc19413750b9bb9cdbf2da20ef5014820 /chromium/gin/data_object_builder_unittest.cc | |
parent | ec02ee4181c49b61fce1c8fb99292dbb8139cc90 (diff) | |
download | qtwebengine-chromium-6ec7b8da05d21a3878bd21c691b41e675d74bb1c.tar.gz |
BASELINE: Update Chromium to 60.0.3112.70
Change-Id: I9911c2280a014d4632f254857876a395d4baed2d
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
Diffstat (limited to 'chromium/gin/data_object_builder_unittest.cc')
-rw-r--r-- | chromium/gin/data_object_builder_unittest.cc | 119 |
1 files changed, 119 insertions, 0 deletions
diff --git a/chromium/gin/data_object_builder_unittest.cc b/chromium/gin/data_object_builder_unittest.cc new file mode 100644 index 00000000000..1629cdf596d --- /dev/null +++ b/chromium/gin/data_object_builder_unittest.cc @@ -0,0 +1,119 @@ +// Copyright 2017 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "gin/data_object_builder.h" + +#include "base/bind.h" +#include "gin/dictionary.h" +#include "gin/public/isolate_holder.h" +#include "gin/test/v8_test.h" + +namespace gin { +namespace { + +using DataObjectBuilderTest = V8Test; + +// It should create ordinary data properties. +TEST_F(DataObjectBuilderTest, CreatesDataProperties) { + v8::Isolate* isolate = instance_->isolate(); + v8::HandleScope handle_scope(isolate); + v8::Local<v8::Context> context = context_.Get(isolate); + + v8::Local<v8::Object> object = + DataObjectBuilder(isolate).Set("key", 42).Build(); + ASSERT_TRUE(object->HasOwnProperty(context, StringToSymbol(isolate, "key")) + .ToChecked()); + + v8::Local<v8::Value> descriptor_object; + ASSERT_TRUE( + object->GetOwnPropertyDescriptor(context, StringToSymbol(isolate, "key")) + .ToLocal(&descriptor_object)); + gin::Dictionary descriptor(isolate, descriptor_object.As<v8::Object>()); + + int32_t value = 0; + ASSERT_TRUE(descriptor.Get("value", &value)); + EXPECT_EQ(42, value); + + bool writable = false; + ASSERT_TRUE(descriptor.Get("writable", &writable)); + EXPECT_TRUE(writable); + + bool enumerable = false; + ASSERT_TRUE(descriptor.Get("enumerable", &enumerable)); + EXPECT_TRUE(enumerable); + + bool configurable = false; + ASSERT_TRUE(descriptor.Get("configurable", &configurable)); + EXPECT_TRUE(configurable); +} + +// It should not invoke setters on the prototype chain. +TEST_F(DataObjectBuilderTest, DoesNotInvokeSetters) { + v8::Isolate* isolate = instance_->isolate(); + v8::HandleScope handle_scope(isolate); + v8::Local<v8::Context> context = context_.Get(isolate); + + // Install a setter on the object prototype. + v8::Local<v8::Value> object_constructor; + ASSERT_TRUE(context->Global() + ->Get(context, StringToSymbol(isolate, "Object")) + .ToLocal(&object_constructor)); + v8::Local<v8::Value> object_prototype; + ASSERT_TRUE(object_constructor.As<v8::Function>() + ->Get(context, StringToSymbol(isolate, "prototype")) + .ToLocal(&object_prototype)); + ASSERT_TRUE( + object_prototype.As<v8::Object>() + ->SetAccessor(context, StringToSymbol(isolate, "key"), + [](v8::Local<v8::Name>, + const v8::PropertyCallbackInfo<v8::Value>&) {}, + [](v8::Local<v8::Name>, v8::Local<v8::Value>, + const v8::PropertyCallbackInfo<void>&) { + ADD_FAILURE() << "setter should not be invoked"; + }) + .ToChecked()); + + // Create an object. + DataObjectBuilder(isolate).Set("key", 42).Build(); +} + +// The internal handle is cleared when the builder is finished. +// This makes the class harder to abuse, so that its methods cannot be used +// after something may have modified the object in unexpected ways. +#if DCHECK_IS_ON() +TEST_F(DataObjectBuilderTest, UnusableAfterBuild) { + v8::Isolate* isolate = instance_->isolate(); + v8::HandleScope handle_scope(isolate); + + DataObjectBuilder builder(isolate); + EXPECT_FALSE(builder.Build().IsEmpty()); + + bool has_dcheck_failure = false; + logging::ScopedLogAssertHandler handler(base::Bind( + [](bool* flag, const char* file, int line, base::StringPiece message, + base::StringPiece stack_trace) { *flag = true; }, + base::Unretained(&has_dcheck_failure))); + builder.Build(); + EXPECT_TRUE(has_dcheck_failure); +} +#endif // DCHECK_IS_ON() + +// As is the normal behaviour of CreateDataProperty, new data properties should +// replace existing ones. Since no non-configurable ones are present, nor should +// the object be non-extensible, this should work. +TEST_F(DataObjectBuilderTest, ReplacesExistingProperties) { + v8::Isolate* isolate = instance_->isolate(); + v8::HandleScope handle_scope(isolate); + + v8::Local<v8::Object> object = + DataObjectBuilder(isolate).Set("value", 42).Set("value", 55).Build(); + + gin::Dictionary dictionary(isolate, object); + int32_t value; + ASSERT_TRUE(dictionary.Get("value", &value)); + EXPECT_EQ(55, value); +} + +} // namespace +} // namespace gin |