[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 1 | // Copyright 2013 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 "gin/converter.h" |
| 6 | |
| 7 | #include <limits.h> |
| 8 | |
| 9 | #include "base/basictypes.h" |
| 10 | #include "base/compiler_specific.h" |
| 11 | #include "base/memory/scoped_ptr.h" |
[email protected] | f04b0e9 | 2013-11-22 14:20:55 | [diff] [blame] | 12 | #include "gin/public/isolate_holder.h" |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 13 | #include "gin/test/v8_test.h" |
| 14 | #include "testing/gtest/include/gtest/gtest.h" |
| 15 | #include "v8/include/v8.h" |
| 16 | |
| 17 | using v8::Array; |
| 18 | using v8::Boolean; |
| 19 | using v8::Handle; |
| 20 | using v8::HandleScope; |
| 21 | using v8::Integer; |
| 22 | using v8::Null; |
| 23 | using v8::Number; |
| 24 | using v8::Object; |
| 25 | using v8::String; |
| 26 | using v8::Undefined; |
| 27 | using v8::Value; |
| 28 | |
| 29 | namespace gin { |
| 30 | |
| 31 | typedef V8Test ConverterTest; |
| 32 | |
| 33 | TEST_F(ConverterTest, Bool) { |
[email protected] | 1b93c23 | 2013-11-19 19:25:12 | [diff] [blame] | 34 | HandleScope handle_scope(instance_->isolate()); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 35 | |
[email protected] | 1b93c23 | 2013-11-19 19:25:12 | [diff] [blame] | 36 | EXPECT_TRUE(Converter<bool>::ToV8(instance_->isolate(), true)->StrictEquals( |
[email protected] | 91cd4fe | 2013-11-28 09:31:58 | [diff] [blame] | 37 | Boolean::New(instance_->isolate(), true))); |
[email protected] | 1b93c23 | 2013-11-19 19:25:12 | [diff] [blame] | 38 | EXPECT_TRUE(Converter<bool>::ToV8(instance_->isolate(), false)->StrictEquals( |
[email protected] | 91cd4fe | 2013-11-28 09:31:58 | [diff] [blame] | 39 | Boolean::New(instance_->isolate(), false))); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 40 | |
| 41 | struct { |
| 42 | Handle<Value> input; |
| 43 | bool expected; |
| 44 | } test_data[] = { |
[email protected] | 91cd4fe | 2013-11-28 09:31:58 | [diff] [blame] | 45 | { Boolean::New(instance_->isolate(), false).As<Value>(), false }, |
| 46 | { Boolean::New(instance_->isolate(), true).As<Value>(), true }, |
| 47 | { Number::New(instance_->isolate(), 0).As<Value>(), false }, |
| 48 | { Number::New(instance_->isolate(), 1).As<Value>(), true }, |
| 49 | { Number::New(instance_->isolate(), -1).As<Value>(), true }, |
| 50 | { Number::New(instance_->isolate(), 0.1).As<Value>(), true }, |
| 51 | { String::NewFromUtf8(instance_->isolate(), "").As<Value>(), false }, |
| 52 | { String::NewFromUtf8(instance_->isolate(), "foo").As<Value>(), true }, |
| 53 | { Object::New(instance_->isolate()).As<Value>(), true }, |
| 54 | { Null(instance_->isolate()).As<Value>(), false }, |
| 55 | { Undefined(instance_->isolate()).As<Value>(), false }, |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 56 | }; |
| 57 | |
| 58 | for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) { |
| 59 | bool result = false; |
[email protected] | 7618ebbb | 2013-11-27 03:38:26 | [diff] [blame] | 60 | EXPECT_TRUE(Converter<bool>::FromV8(instance_->isolate(), |
| 61 | test_data[i].input, &result)); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 62 | EXPECT_EQ(test_data[i].expected, result); |
| 63 | |
| 64 | result = true; |
[email protected] | 7618ebbb | 2013-11-27 03:38:26 | [diff] [blame] | 65 | EXPECT_TRUE(Converter<bool>::FromV8(instance_->isolate(), |
| 66 | test_data[i].input, &result)); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 67 | EXPECT_EQ(test_data[i].expected, result); |
| 68 | } |
| 69 | } |
| 70 | |
| 71 | TEST_F(ConverterTest, Int32) { |
[email protected] | 1b93c23 | 2013-11-19 19:25:12 | [diff] [blame] | 72 | HandleScope handle_scope(instance_->isolate()); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 73 | |
| 74 | int test_data_to[] = {-1, 0, 1}; |
| 75 | for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data_to); ++i) { |
[email protected] | add8fb17 | 2014-01-03 15:13:49 | [diff] [blame] | 76 | EXPECT_TRUE(Converter<int32_t>::ToV8(instance_->isolate(), test_data_to[i]) |
| 77 | ->StrictEquals( |
| 78 | Integer::New(instance_->isolate(), test_data_to[i]))); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 79 | } |
| 80 | |
| 81 | struct { |
| 82 | v8::Handle<v8::Value> input; |
| 83 | bool expect_sucess; |
| 84 | int expected_result; |
| 85 | } test_data_from[] = { |
[email protected] | 91cd4fe | 2013-11-28 09:31:58 | [diff] [blame] | 86 | { Boolean::New(instance_->isolate(), false).As<Value>(), false, 0 }, |
| 87 | { Boolean::New(instance_->isolate(), true).As<Value>(), false, 0 }, |
| 88 | { Integer::New(instance_->isolate(), -1).As<Value>(), true, -1 }, |
| 89 | { Integer::New(instance_->isolate(), 0).As<Value>(), true, 0 }, |
| 90 | { Integer::New(instance_->isolate(), 1).As<Value>(), true, 1 }, |
| 91 | { Number::New(instance_->isolate(), -1).As<Value>(), true, -1 }, |
| 92 | { Number::New(instance_->isolate(), 1.1).As<Value>(), false, 0 }, |
| 93 | { String::NewFromUtf8(instance_->isolate(), "42").As<Value>(), false, 0 }, |
| 94 | { String::NewFromUtf8(instance_->isolate(), "foo").As<Value>(), false, 0 }, |
| 95 | { Object::New(instance_->isolate()).As<Value>(), false, 0 }, |
| 96 | { Array::New(instance_->isolate()).As<Value>(), false, 0 }, |
| 97 | { v8::Null(instance_->isolate()).As<Value>(), false, 0 }, |
| 98 | { v8::Undefined(instance_->isolate()).As<Value>(), false, 0 }, |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 99 | }; |
| 100 | |
| 101 | for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data_from); ++i) { |
| 102 | int32_t result = std::numeric_limits<int32_t>::min(); |
[email protected] | 7618ebbb | 2013-11-27 03:38:26 | [diff] [blame] | 103 | bool success = Converter<int32_t>::FromV8(instance_->isolate(), |
| 104 | test_data_from[i].input, &result); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 105 | EXPECT_EQ(test_data_from[i].expect_sucess, success) << i; |
| 106 | if (success) |
| 107 | EXPECT_EQ(test_data_from[i].expected_result, result) << i; |
| 108 | } |
| 109 | } |
| 110 | |
| 111 | TEST_F(ConverterTest, Vector) { |
[email protected] | 1b93c23 | 2013-11-19 19:25:12 | [diff] [blame] | 112 | HandleScope handle_scope(instance_->isolate()); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 113 | |
| 114 | std::vector<int> expected; |
| 115 | expected.push_back(-1); |
| 116 | expected.push_back(0); |
| 117 | expected.push_back(1); |
| 118 | |
| 119 | Handle<Array> js_array = Handle<Array>::Cast( |
[email protected] | 1b93c23 | 2013-11-19 19:25:12 | [diff] [blame] | 120 | Converter<std::vector<int> >::ToV8(instance_->isolate(), expected)); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 121 | ASSERT_FALSE(js_array.IsEmpty()); |
| 122 | EXPECT_EQ(3u, js_array->Length()); |
| 123 | for (size_t i = 0; i < expected.size(); ++i) { |
[email protected] | 91cd4fe | 2013-11-28 09:31:58 | [diff] [blame] | 124 | EXPECT_TRUE(Integer::New(instance_->isolate(), expected[i]) |
| 125 | ->StrictEquals(js_array->Get(static_cast<int>(i)))); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 126 | } |
| 127 | |
| 128 | std::vector<int> actual; |
[email protected] | 7618ebbb | 2013-11-27 03:38:26 | [diff] [blame] | 129 | EXPECT_TRUE(Converter<std::vector<int> >::FromV8(instance_->isolate(), |
| 130 | js_array, &actual)); |
[email protected] | a22998a | 2013-11-10 05:00:50 | [diff] [blame] | 131 | EXPECT_EQ(expected, actual); |
| 132 | } |
| 133 | |
| 134 | } // namespace gin |