extensions/renderer/activity_log_converter_strategy_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "base/values.h"
   7 #include "extensions/renderer/activity_log_converter_strategy.h"
   8 #include "extensions/renderer/scoped_persistent.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "v8/include/v8.h"
  11
  12 using content::V8ValueConverter;
  13
  14 namespace extensions {
  15
  16 class ActivityLogConverterStrategyTest : public testing::Test {
  17  public:
  18   ActivityLogConverterStrategyTest()
  19       : isolate_(v8::Isolate::GetCurrent())
  20       , handle_scope_(isolate_)
  21       , context_(v8::Context::New(isolate_))
  22       , context_scope_(context()) {
  23   }
  24
  25  protected:
  26   void SetUp() override {
  27     converter_.reset(V8ValueConverter::create());
  28     strategy_.reset(new ActivityLogConverterStrategy());
  29     converter_->SetFunctionAllowed(true);
  30     converter_->SetStrategy(strategy_.get());
  31   }
  32
  33   testing::AssertionResult VerifyNull(v8::Local<v8::Value> v8_value) {
  34     scoped_ptr<base::Value> value(
  35         converter_->FromV8Value(v8_value, context()));
  36     if (value->IsType(base::Value::TYPE_NULL))
  37       return testing::AssertionSuccess();
  38     return testing::AssertionFailure();
  39   }
  40
  41   testing::AssertionResult VerifyBoolean(v8::Local<v8::Value> v8_value,
  42                                          bool expected) {
  43     bool out;
  44     scoped_ptr<base::Value> value(
  45         converter_->FromV8Value(v8_value, context()));
  46     if (value->IsType(base::Value::TYPE_BOOLEAN)
  47         && value->GetAsBoolean(&out)
  48         && out == expected)
  49       return testing::AssertionSuccess();
  50     return testing::AssertionFailure();
  51   }
  52
  53   testing::AssertionResult VerifyInteger(v8::Local<v8::Value> v8_value,
  54                                          int expected) {
  55     int out;
  56     scoped_ptr<base::Value> value(
  57         converter_->FromV8Value(v8_value, context()));
  58     if (value->IsType(base::Value::TYPE_INTEGER)
  59         && value->GetAsInteger(&out)
  60         && out == expected)
  61       return testing::AssertionSuccess();
  62     return testing::AssertionFailure();
  63   }
  64
  65   testing::AssertionResult VerifyDouble(v8::Local<v8::Value> v8_value,
  66                                         double expected) {
  67     double out;
  68     scoped_ptr<base::Value> value(
  69         converter_->FromV8Value(v8_value, context()));
  70     if (value->IsType(base::Value::TYPE_DOUBLE)
  71         && value->GetAsDouble(&out)
  72         && out == expected)
  73       return testing::AssertionSuccess();
  74     return testing::AssertionFailure();
  75   }
  76
  77   testing::AssertionResult VerifyString(v8::Local<v8::Value> v8_value,
  78                                         const std::string& expected) {
  79     std::string out;
  80     scoped_ptr<base::Value> value(
  81         converter_->FromV8Value(v8_value, context()));
  82     if (value->IsType(base::Value::TYPE_STRING)
  83         && value->GetAsString(&out)
  84         && out == expected)
  85       return testing::AssertionSuccess();
  86     return testing::AssertionFailure();
  87   }
  88
  89   v8::Handle<v8::Context> context() const {
  90     return context_.NewHandle(isolate_);
  91   }
  92
  93   v8::Isolate* isolate_;
  94   v8::HandleScope handle_scope_;
  95   ScopedPersistent<v8::Context> context_;
  96   v8::Context::Scope context_scope_;
  97   scoped_ptr<V8ValueConverter> converter_;
  98   scoped_ptr<ActivityLogConverterStrategy> strategy_;
  99 };
 100
 101 TEST_F(ActivityLogConverterStrategyTest, ConversionTest) {
 102   const char* source = "(function() {"
 103       "function foo() {}"
 104       "return {"
 105         "null: null,"
 106         "true: true,"
 107         "false: false,"
 108         "positive_int: 42,"
 109         "negative_int: -42,"
 110         "zero: 0,"
 111         "double: 88.8,"
 112         "big_integral_double: 9007199254740992.0,"  // 2.0^53
 113         "string: \"foobar\","
 114         "empty_string: \"\","
 115         "dictionary: {"
 116           "foo: \"bar\","
 117           "hot: \"dog\","
 118         "},"
 119         "empty_dictionary: {},"
 120         "list: [ \"monkey\", \"balls\" ],"
 121         "empty_list: [],"
 122         "function: function() {},"
 123         "named_function: foo"
 124       "};"
 125       "})();";
 126
 127   v8::Handle<v8::Script> script(
 128       v8::Script::Compile(v8::String::NewFromUtf8(isolate_, source)));
 129   v8::Handle<v8::Object> v8_object = script->Run().As<v8::Object>();
 130
 131   EXPECT_TRUE(VerifyString(v8_object, "[Object]"));
 132   EXPECT_TRUE(
 133       VerifyNull(v8_object->Get(v8::String::NewFromUtf8(isolate_, "null"))));
 134   EXPECT_TRUE(VerifyBoolean(
 135       v8_object->Get(v8::String::NewFromUtf8(isolate_, "true")), true));
 136   EXPECT_TRUE(VerifyBoolean(
 137       v8_object->Get(v8::String::NewFromUtf8(isolate_, "false")), false));
 138   EXPECT_TRUE(VerifyInteger(
 139       v8_object->Get(v8::String::NewFromUtf8(isolate_, "positive_int")), 42));
 140   EXPECT_TRUE(VerifyInteger(
 141       v8_object->Get(v8::String::NewFromUtf8(isolate_, "negative_int")), -42));
 142   EXPECT_TRUE(VerifyInteger(
 143       v8_object->Get(v8::String::NewFromUtf8(isolate_, "zero")), 0));
 144   EXPECT_TRUE(VerifyDouble(
 145       v8_object->Get(v8::String::NewFromUtf8(isolate_, "double")), 88.8));
 146   EXPECT_TRUE(VerifyDouble(
 147       v8_object->Get(v8::String::NewFromUtf8(isolate_, "big_integral_double")),
 148       9007199254740992.0));
 149   EXPECT_TRUE(VerifyString(
 150       v8_object->Get(v8::String::NewFromUtf8(isolate_, "string")), "foobar"));
 151   EXPECT_TRUE(VerifyString(
 152       v8_object->Get(v8::String::NewFromUtf8(isolate_, "empty_string")), ""));
 153   EXPECT_TRUE(VerifyString(
 154       v8_object->Get(v8::String::NewFromUtf8(isolate_, "dictionary")),
 155       "[Object]"));
 156   EXPECT_TRUE(VerifyString(
 157       v8_object->Get(v8::String::NewFromUtf8(isolate_, "empty_dictionary")),
 158       "[Object]"));
 159   EXPECT_TRUE(VerifyString(
 160       v8_object->Get(v8::String::NewFromUtf8(isolate_, "list")), "[Array]"));
 161   EXPECT_TRUE(VerifyString(
 162       v8_object->Get(v8::String::NewFromUtf8(isolate_, "empty_list")),
 163       "[Array]"));
 164   EXPECT_TRUE(VerifyString(
 165       v8_object->Get(v8::String::NewFromUtf8(isolate_, "function")),
 166       "[Function]"));
 167   EXPECT_TRUE(VerifyString(
 168       v8_object->Get(v8::String::NewFromUtf8(isolate_, "named_function")),
 169       "[Function foo()]"));
 170 }
 171
 172 }  // namespace extensions