OLD | NEW |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "testing/gtest/include/gtest/gtest.h" | 5 #include "testing/gtest/include/gtest/gtest.h" |
6 #include "tools/gn/err.h" | 6 #include "tools/gn/err.h" |
7 #include "tools/gn/input_conversion.h" | 7 #include "tools/gn/input_conversion.h" |
| 8 #include "tools/gn/input_file.h" |
| 9 #include "tools/gn/parse_tree.h" |
| 10 #include "tools/gn/scheduler.h" |
| 11 #include "tools/gn/test_with_scope.h" |
8 #include "tools/gn/value.h" | 12 #include "tools/gn/value.h" |
9 | 13 |
10 TEST(InputConversion, String) { | 14 namespace { |
| 15 |
| 16 // InputConversion needs a global scheduler object. |
| 17 class InputConversionTest : public testing::Test { |
| 18 public: |
| 19 InputConversionTest() {} |
| 20 |
| 21 const Settings* settings() { return setup_.settings(); } |
| 22 |
| 23 private: |
| 24 TestWithScope setup_; |
| 25 |
| 26 Scheduler scheduler_; |
| 27 }; |
| 28 |
| 29 } // namespace |
| 30 |
| 31 TEST_F(InputConversionTest, String) { |
11 Err err; | 32 Err err; |
12 std::string input("\nfoo bar \n"); | 33 std::string input("\nfoo bar \n"); |
13 Value result = ConvertInputToValue(input, NULL, Value(NULL, "string"), &err); | 34 Value result = ConvertInputToValue(settings(), input, NULL, |
| 35 Value(NULL, "string"), &err); |
14 EXPECT_FALSE(err.has_error()); | 36 EXPECT_FALSE(err.has_error()); |
15 EXPECT_EQ(Value::STRING, result.type()); | 37 EXPECT_EQ(Value::STRING, result.type()); |
16 EXPECT_EQ(input, result.string_value()); | 38 EXPECT_EQ(input, result.string_value()); |
17 | 39 |
18 // Test with trimming. | 40 // Test with trimming. |
19 result = ConvertInputToValue(input, NULL, Value(NULL, "trim string"), &err); | 41 result = ConvertInputToValue(settings(), input, NULL, |
| 42 Value(NULL, "trim string"), &err); |
20 EXPECT_FALSE(err.has_error()); | 43 EXPECT_FALSE(err.has_error()); |
21 EXPECT_EQ(Value::STRING, result.type()); | 44 EXPECT_EQ(Value::STRING, result.type()); |
22 EXPECT_EQ("foo bar", result.string_value()); | 45 EXPECT_EQ("foo bar", result.string_value()); |
23 } | 46 } |
24 | 47 |
25 TEST(InputConversion, ListLines) { | 48 TEST_F(InputConversionTest, ListLines) { |
26 Err err; | 49 Err err; |
27 std::string input("\nfoo\nbar \n\n"); | 50 std::string input("\nfoo\nbar \n\n"); |
28 Value result = ConvertInputToValue(input, NULL, Value(NULL, "list lines"), | 51 Value result = ConvertInputToValue(settings(), input, NULL, |
29 &err); | 52 Value(NULL, "list lines"), &err); |
30 EXPECT_FALSE(err.has_error()); | 53 EXPECT_FALSE(err.has_error()); |
31 EXPECT_EQ(Value::LIST, result.type()); | 54 EXPECT_EQ(Value::LIST, result.type()); |
32 ASSERT_EQ(4u, result.list_value().size()); | 55 ASSERT_EQ(4u, result.list_value().size()); |
33 EXPECT_EQ("", result.list_value()[0].string_value()); | 56 EXPECT_EQ("", result.list_value()[0].string_value()); |
34 EXPECT_EQ("foo", result.list_value()[1].string_value()); | 57 EXPECT_EQ("foo", result.list_value()[1].string_value()); |
35 EXPECT_EQ("bar", result.list_value()[2].string_value()); | 58 EXPECT_EQ("bar", result.list_value()[2].string_value()); |
36 EXPECT_EQ("", result.list_value()[3].string_value()); | 59 EXPECT_EQ("", result.list_value()[3].string_value()); |
37 | 60 |
38 // Test with trimming. | 61 // Test with trimming. |
39 result = ConvertInputToValue(input, NULL, Value(NULL, "trim list lines"), | 62 result = ConvertInputToValue(settings(), input, NULL, |
40 &err); | 63 Value(NULL, "trim list lines"), &err); |
41 EXPECT_FALSE(err.has_error()); | 64 EXPECT_FALSE(err.has_error()); |
42 EXPECT_EQ(Value::LIST, result.type()); | 65 EXPECT_EQ(Value::LIST, result.type()); |
43 ASSERT_EQ(2u, result.list_value().size()); | 66 ASSERT_EQ(2u, result.list_value().size()); |
44 EXPECT_EQ("foo", result.list_value()[0].string_value()); | 67 EXPECT_EQ("foo", result.list_value()[0].string_value()); |
45 EXPECT_EQ("bar", result.list_value()[1].string_value()); | 68 EXPECT_EQ("bar", result.list_value()[1].string_value()); |
46 } | 69 } |
47 | 70 |
48 TEST(InputConversion, ValueString) { | 71 TEST_F(InputConversionTest, ValueString) { |
49 Err err; | 72 Err err; |
50 std::string input("\"str\""); | 73 std::string input("\"str\""); |
51 Value result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err); | 74 Value result = ConvertInputToValue(settings(), input, NULL, |
| 75 Value(NULL, "value"), &err); |
52 EXPECT_FALSE(err.has_error()); | 76 EXPECT_FALSE(err.has_error()); |
53 EXPECT_EQ(Value::STRING, result.type()); | 77 EXPECT_EQ(Value::STRING, result.type()); |
54 EXPECT_EQ("str", result.string_value()); | 78 EXPECT_EQ("str", result.string_value()); |
55 } | 79 } |
56 | 80 |
57 TEST(InputConversion, ValueInt) { | 81 TEST_F(InputConversionTest, ValueInt) { |
58 Err err; | 82 Err err; |
59 std::string input("\n\n 6 \n "); | 83 std::string input("\n\n 6 \n "); |
60 Value result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err); | 84 Value result = ConvertInputToValue(settings(), input, NULL, |
| 85 Value(NULL, "value"), &err); |
61 EXPECT_FALSE(err.has_error()); | 86 EXPECT_FALSE(err.has_error()); |
62 EXPECT_EQ(Value::INTEGER, result.type()); | 87 EXPECT_EQ(Value::INTEGER, result.type()); |
63 EXPECT_EQ(6, result.int_value()); | 88 EXPECT_EQ(6, result.int_value()); |
64 } | 89 } |
65 | 90 |
66 TEST(InputConversion, ValueList) { | 91 TEST_F(InputConversionTest, ValueList) { |
67 Err err; | 92 Err err; |
68 std::string input("\n [ \"a\", 5]"); | 93 std::string input("\n [ \"a\", 5]"); |
69 Value result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err); | 94 Value result = ConvertInputToValue(settings(), input, NULL, |
| 95 Value(NULL, "value"), &err); |
70 EXPECT_FALSE(err.has_error()); | 96 EXPECT_FALSE(err.has_error()); |
71 ASSERT_EQ(Value::LIST, result.type()); | 97 ASSERT_EQ(Value::LIST, result.type()); |
72 ASSERT_EQ(2u, result.list_value().size()); | 98 ASSERT_EQ(2u, result.list_value().size()); |
73 EXPECT_EQ("a", result.list_value()[0].string_value()); | 99 EXPECT_EQ("a", result.list_value()[0].string_value()); |
74 EXPECT_EQ(5, result.list_value()[1].int_value()); | 100 EXPECT_EQ(5, result.list_value()[1].int_value()); |
75 } | 101 } |
76 | 102 |
77 TEST(InputConversion, ValueEmpty) { | 103 TEST_F(InputConversionTest, ValueDict) { |
78 Err err; | 104 Err err; |
79 Value result = ConvertInputToValue("", NULL, Value(NULL, "value"), &err); | 105 std::string input("\n a = 5 b = \"foo\" c = a + 2"); |
| 106 Value result = ConvertInputToValue(settings(), input, NULL, |
| 107 Value(NULL, "scope"), &err); |
| 108 EXPECT_FALSE(err.has_error()); |
| 109 ASSERT_EQ(Value::SCOPE, result.type()); |
| 110 |
| 111 const Value* a_value = result.scope_value()->GetValue("a"); |
| 112 ASSERT_TRUE(a_value); |
| 113 EXPECT_EQ(5, a_value->int_value()); |
| 114 |
| 115 const Value* b_value = result.scope_value()->GetValue("b"); |
| 116 ASSERT_TRUE(b_value); |
| 117 EXPECT_EQ("foo", b_value->string_value()); |
| 118 |
| 119 const Value* c_value = result.scope_value()->GetValue("c"); |
| 120 ASSERT_TRUE(c_value); |
| 121 EXPECT_EQ(7, c_value->int_value()); |
| 122 |
| 123 // Tests that when we get Values out of the input conversion, the resulting |
| 124 // values have an origin set to something corresponding to the input. |
| 125 const ParseNode* a_origin = a_value->origin(); |
| 126 ASSERT_TRUE(a_origin); |
| 127 LocationRange a_range = a_origin->GetRange(); |
| 128 EXPECT_EQ(2, a_range.begin().line_number()); |
| 129 EXPECT_EQ(6, a_range.begin().char_offset()); |
| 130 |
| 131 const InputFile* a_file = a_range.begin().file(); |
| 132 EXPECT_EQ(input, a_file->contents()); |
| 133 } |
| 134 |
| 135 TEST_F(InputConversionTest, ValueEmpty) { |
| 136 Err err; |
| 137 Value result = ConvertInputToValue(settings(), "", NULL, |
| 138 Value(NULL, "value"), &err); |
80 EXPECT_FALSE(err.has_error()); | 139 EXPECT_FALSE(err.has_error()); |
81 EXPECT_EQ(Value::NONE, result.type()); | 140 EXPECT_EQ(Value::NONE, result.type()); |
82 } | 141 } |
83 | 142 |
84 TEST(InputConversion, ValueError) { | 143 TEST_F(InputConversionTest, ValueError) { |
85 Err err; | 144 Err err; |
86 std::string input("\n [ \"a\", 5\nfoo bar"); | 145 std::string input("\n [ \"a\", 5\nfoo bar"); |
87 Value result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err); | 146 Value result = ConvertInputToValue(settings(), input, NULL, |
| 147 Value(NULL, "value"), &err); |
88 EXPECT_TRUE(err.has_error()); | 148 EXPECT_TRUE(err.has_error()); |
89 | 149 |
90 // Blocks not allowed. | 150 // Blocks not allowed. |
91 input = "{ foo = 5 }"; | 151 input = "{ foo = 5 }"; |
92 result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err); | 152 result = ConvertInputToValue(settings(), input, NULL, |
| 153 Value(NULL, "value"), &err); |
93 EXPECT_TRUE(err.has_error()); | 154 EXPECT_TRUE(err.has_error()); |
94 | 155 |
95 // Function calls not allowed. | 156 // Function calls not allowed. |
96 input = "print(5)"; | 157 input = "print(5)"; |
97 result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err); | 158 result = ConvertInputToValue(settings(), input, NULL, |
| 159 Value(NULL, "value"), &err); |
98 EXPECT_TRUE(err.has_error()); | 160 EXPECT_TRUE(err.has_error()); |
99 } | 161 } |
100 | 162 |
101 // Passing none or the empty string for input conversion should ignore the | 163 // Passing none or the empty string for input conversion should ignore the |
102 // result. | 164 // result. |
103 TEST(InputConversion, Ignore) { | 165 TEST_F(InputConversionTest, Ignore) { |
104 Err err; | 166 Err err; |
105 Value result = ConvertInputToValue("foo", NULL, Value(), &err); | 167 Value result = ConvertInputToValue(settings(), "foo", NULL, Value(), &err); |
106 EXPECT_FALSE(err.has_error()); | 168 EXPECT_FALSE(err.has_error()); |
107 EXPECT_EQ(Value::NONE, result.type()); | 169 EXPECT_EQ(Value::NONE, result.type()); |
108 | 170 |
109 result = ConvertInputToValue("foo", NULL, Value(NULL, ""), &err); | 171 result = ConvertInputToValue(settings(), "foo", NULL, Value(NULL, ""), &err); |
110 EXPECT_FALSE(err.has_error()); | 172 EXPECT_FALSE(err.has_error()); |
111 EXPECT_EQ(Value::NONE, result.type()); | 173 EXPECT_EQ(Value::NONE, result.type()); |
112 } | 174 } |
OLD | NEW |