OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "base/json/json_parser.h" | 5 #include "base/json/json_parser.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
| 9 #include <memory> |
| 10 |
9 #include "base/json/json_reader.h" | 11 #include "base/json/json_reader.h" |
10 #include "base/memory/scoped_ptr.h" | |
11 #include "base/values.h" | 12 #include "base/values.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 13 #include "testing/gtest/include/gtest/gtest.h" |
13 | 14 |
14 namespace base { | 15 namespace base { |
15 namespace internal { | 16 namespace internal { |
16 | 17 |
17 class JSONParserTest : public testing::Test { | 18 class JSONParserTest : public testing::Test { |
18 public: | 19 public: |
19 JSONParser* NewTestParser(const std::string& input) { | 20 JSONParser* NewTestParser(const std::string& input) { |
20 JSONParser* parser = new JSONParser(JSON_PARSE_RFC); | 21 JSONParser* parser = new JSONParser(JSON_PARSE_RFC); |
21 parser->start_pos_ = input.data(); | 22 parser->start_pos_ = input.data(); |
22 parser->pos_ = parser->start_pos_; | 23 parser->pos_ = parser->start_pos_; |
23 parser->end_pos_ = parser->start_pos_ + input.length(); | 24 parser->end_pos_ = parser->start_pos_ + input.length(); |
24 return parser; | 25 return parser; |
25 } | 26 } |
26 | 27 |
27 void TestLastThree(JSONParser* parser) { | 28 void TestLastThree(JSONParser* parser) { |
28 EXPECT_EQ(',', *parser->NextChar()); | 29 EXPECT_EQ(',', *parser->NextChar()); |
29 EXPECT_EQ('|', *parser->NextChar()); | 30 EXPECT_EQ('|', *parser->NextChar()); |
30 EXPECT_EQ('\0', *parser->NextChar()); | 31 EXPECT_EQ('\0', *parser->NextChar()); |
31 EXPECT_EQ(parser->end_pos_, parser->pos_); | 32 EXPECT_EQ(parser->end_pos_, parser->pos_); |
32 } | 33 } |
33 }; | 34 }; |
34 | 35 |
35 TEST_F(JSONParserTest, NextChar) { | 36 TEST_F(JSONParserTest, NextChar) { |
36 std::string input("Hello world"); | 37 std::string input("Hello world"); |
37 scoped_ptr<JSONParser> parser(NewTestParser(input)); | 38 std::unique_ptr<JSONParser> parser(NewTestParser(input)); |
38 | 39 |
39 EXPECT_EQ('H', *parser->pos_); | 40 EXPECT_EQ('H', *parser->pos_); |
40 for (size_t i = 1; i < input.length(); ++i) { | 41 for (size_t i = 1; i < input.length(); ++i) { |
41 EXPECT_EQ(input[i], *parser->NextChar()); | 42 EXPECT_EQ(input[i], *parser->NextChar()); |
42 } | 43 } |
43 EXPECT_EQ(parser->end_pos_, parser->NextChar()); | 44 EXPECT_EQ(parser->end_pos_, parser->NextChar()); |
44 } | 45 } |
45 | 46 |
46 TEST_F(JSONParserTest, ConsumeString) { | 47 TEST_F(JSONParserTest, ConsumeString) { |
47 std::string input("\"test\",|"); | 48 std::string input("\"test\",|"); |
48 scoped_ptr<JSONParser> parser(NewTestParser(input)); | 49 std::unique_ptr<JSONParser> parser(NewTestParser(input)); |
49 scoped_ptr<Value> value(parser->ConsumeString()); | 50 std::unique_ptr<Value> value(parser->ConsumeString()); |
50 EXPECT_EQ('"', *parser->pos_); | 51 EXPECT_EQ('"', *parser->pos_); |
51 | 52 |
52 TestLastThree(parser.get()); | 53 TestLastThree(parser.get()); |
53 | 54 |
54 ASSERT_TRUE(value.get()); | 55 ASSERT_TRUE(value.get()); |
55 std::string str; | 56 std::string str; |
56 EXPECT_TRUE(value->GetAsString(&str)); | 57 EXPECT_TRUE(value->GetAsString(&str)); |
57 EXPECT_EQ("test", str); | 58 EXPECT_EQ("test", str); |
58 } | 59 } |
59 | 60 |
60 TEST_F(JSONParserTest, ConsumeList) { | 61 TEST_F(JSONParserTest, ConsumeList) { |
61 std::string input("[true, false],|"); | 62 std::string input("[true, false],|"); |
62 scoped_ptr<JSONParser> parser(NewTestParser(input)); | 63 std::unique_ptr<JSONParser> parser(NewTestParser(input)); |
63 scoped_ptr<Value> value(parser->ConsumeList()); | 64 std::unique_ptr<Value> value(parser->ConsumeList()); |
64 EXPECT_EQ(']', *parser->pos_); | 65 EXPECT_EQ(']', *parser->pos_); |
65 | 66 |
66 TestLastThree(parser.get()); | 67 TestLastThree(parser.get()); |
67 | 68 |
68 ASSERT_TRUE(value.get()); | 69 ASSERT_TRUE(value.get()); |
69 base::ListValue* list; | 70 base::ListValue* list; |
70 EXPECT_TRUE(value->GetAsList(&list)); | 71 EXPECT_TRUE(value->GetAsList(&list)); |
71 EXPECT_EQ(2u, list->GetSize()); | 72 EXPECT_EQ(2u, list->GetSize()); |
72 } | 73 } |
73 | 74 |
74 TEST_F(JSONParserTest, ConsumeDictionary) { | 75 TEST_F(JSONParserTest, ConsumeDictionary) { |
75 std::string input("{\"abc\":\"def\"},|"); | 76 std::string input("{\"abc\":\"def\"},|"); |
76 scoped_ptr<JSONParser> parser(NewTestParser(input)); | 77 std::unique_ptr<JSONParser> parser(NewTestParser(input)); |
77 scoped_ptr<Value> value(parser->ConsumeDictionary()); | 78 std::unique_ptr<Value> value(parser->ConsumeDictionary()); |
78 EXPECT_EQ('}', *parser->pos_); | 79 EXPECT_EQ('}', *parser->pos_); |
79 | 80 |
80 TestLastThree(parser.get()); | 81 TestLastThree(parser.get()); |
81 | 82 |
82 ASSERT_TRUE(value.get()); | 83 ASSERT_TRUE(value.get()); |
83 base::DictionaryValue* dict; | 84 base::DictionaryValue* dict; |
84 EXPECT_TRUE(value->GetAsDictionary(&dict)); | 85 EXPECT_TRUE(value->GetAsDictionary(&dict)); |
85 std::string str; | 86 std::string str; |
86 EXPECT_TRUE(dict->GetString("abc", &str)); | 87 EXPECT_TRUE(dict->GetString("abc", &str)); |
87 EXPECT_EQ("def", str); | 88 EXPECT_EQ("def", str); |
88 } | 89 } |
89 | 90 |
90 TEST_F(JSONParserTest, ConsumeLiterals) { | 91 TEST_F(JSONParserTest, ConsumeLiterals) { |
91 // Literal |true|. | 92 // Literal |true|. |
92 std::string input("true,|"); | 93 std::string input("true,|"); |
93 scoped_ptr<JSONParser> parser(NewTestParser(input)); | 94 std::unique_ptr<JSONParser> parser(NewTestParser(input)); |
94 scoped_ptr<Value> value(parser->ConsumeLiteral()); | 95 std::unique_ptr<Value> value(parser->ConsumeLiteral()); |
95 EXPECT_EQ('e', *parser->pos_); | 96 EXPECT_EQ('e', *parser->pos_); |
96 | 97 |
97 TestLastThree(parser.get()); | 98 TestLastThree(parser.get()); |
98 | 99 |
99 ASSERT_TRUE(value.get()); | 100 ASSERT_TRUE(value.get()); |
100 bool bool_value = false; | 101 bool bool_value = false; |
101 EXPECT_TRUE(value->GetAsBoolean(&bool_value)); | 102 EXPECT_TRUE(value->GetAsBoolean(&bool_value)); |
102 EXPECT_TRUE(bool_value); | 103 EXPECT_TRUE(bool_value); |
103 | 104 |
104 // Literal |false|. | 105 // Literal |false|. |
(...skipping 16 matching lines...) Expand all Loading... |
121 | 122 |
122 TestLastThree(parser.get()); | 123 TestLastThree(parser.get()); |
123 | 124 |
124 ASSERT_TRUE(value.get()); | 125 ASSERT_TRUE(value.get()); |
125 EXPECT_TRUE(value->IsType(Value::TYPE_NULL)); | 126 EXPECT_TRUE(value->IsType(Value::TYPE_NULL)); |
126 } | 127 } |
127 | 128 |
128 TEST_F(JSONParserTest, ConsumeNumbers) { | 129 TEST_F(JSONParserTest, ConsumeNumbers) { |
129 // Integer. | 130 // Integer. |
130 std::string input("1234,|"); | 131 std::string input("1234,|"); |
131 scoped_ptr<JSONParser> parser(NewTestParser(input)); | 132 std::unique_ptr<JSONParser> parser(NewTestParser(input)); |
132 scoped_ptr<Value> value(parser->ConsumeNumber()); | 133 std::unique_ptr<Value> value(parser->ConsumeNumber()); |
133 EXPECT_EQ('4', *parser->pos_); | 134 EXPECT_EQ('4', *parser->pos_); |
134 | 135 |
135 TestLastThree(parser.get()); | 136 TestLastThree(parser.get()); |
136 | 137 |
137 ASSERT_TRUE(value.get()); | 138 ASSERT_TRUE(value.get()); |
138 int number_i; | 139 int number_i; |
139 EXPECT_TRUE(value->GetAsInteger(&number_i)); | 140 EXPECT_TRUE(value->GetAsInteger(&number_i)); |
140 EXPECT_EQ(1234, number_i); | 141 EXPECT_EQ(1234, number_i); |
141 | 142 |
142 // Negative integer. | 143 // Negative integer. |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
198 | 199 |
199 ASSERT_TRUE(value.get()); | 200 ASSERT_TRUE(value.get()); |
200 EXPECT_TRUE(value->GetAsDouble(&number_d)); | 201 EXPECT_TRUE(value->GetAsDouble(&number_d)); |
201 EXPECT_EQ(420, number_d); | 202 EXPECT_EQ(420, number_d); |
202 } | 203 } |
203 | 204 |
204 TEST_F(JSONParserTest, ErrorMessages) { | 205 TEST_F(JSONParserTest, ErrorMessages) { |
205 // Error strings should not be modified in case of success. | 206 // Error strings should not be modified in case of success. |
206 std::string error_message; | 207 std::string error_message; |
207 int error_code = 0; | 208 int error_code = 0; |
208 scoped_ptr<Value> root = JSONReader::ReadAndReturnError( | 209 std::unique_ptr<Value> root = JSONReader::ReadAndReturnError( |
209 "[42]", JSON_PARSE_RFC, &error_code, &error_message); | 210 "[42]", JSON_PARSE_RFC, &error_code, &error_message); |
210 EXPECT_TRUE(error_message.empty()); | 211 EXPECT_TRUE(error_message.empty()); |
211 EXPECT_EQ(0, error_code); | 212 EXPECT_EQ(0, error_code); |
212 | 213 |
213 // Test line and column counting | 214 // Test line and column counting |
214 const char big_json[] = "[\n0,\n1,\n2,\n3,4,5,6 7,\n8,\n9\n]"; | 215 const char big_json[] = "[\n0,\n1,\n2,\n3,4,5,6 7,\n8,\n9\n]"; |
215 // error here ----------------------------------^ | 216 // error here ----------------------------------^ |
216 root = JSONReader::ReadAndReturnError(big_json, JSON_PARSE_RFC, &error_code, | 217 root = JSONReader::ReadAndReturnError(big_json, JSON_PARSE_RFC, &error_code, |
217 &error_message); | 218 &error_message); |
218 EXPECT_FALSE(root.get()); | 219 EXPECT_FALSE(root.get()); |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
302 EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code); | 303 EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code); |
303 } | 304 } |
304 | 305 |
305 TEST_F(JSONParserTest, Decode4ByteUtf8Char) { | 306 TEST_F(JSONParserTest, Decode4ByteUtf8Char) { |
306 // This test strings contains a 4 byte unicode character (a smiley!) that the | 307 // This test strings contains a 4 byte unicode character (a smiley!) that the |
307 // reader should be able to handle (the character is \xf0\x9f\x98\x87). | 308 // reader should be able to handle (the character is \xf0\x9f\x98\x87). |
308 const char kUtf8Data[] = | 309 const char kUtf8Data[] = |
309 "[\"😇\",[],[],[],{\"google:suggesttype\":[]}]"; | 310 "[\"😇\",[],[],[],{\"google:suggesttype\":[]}]"; |
310 std::string error_message; | 311 std::string error_message; |
311 int error_code = 0; | 312 int error_code = 0; |
312 scoped_ptr<Value> root = JSONReader::ReadAndReturnError( | 313 std::unique_ptr<Value> root = JSONReader::ReadAndReturnError( |
313 kUtf8Data, JSON_PARSE_RFC, &error_code, &error_message); | 314 kUtf8Data, JSON_PARSE_RFC, &error_code, &error_message); |
314 EXPECT_TRUE(root.get()) << error_message; | 315 EXPECT_TRUE(root.get()) << error_message; |
315 } | 316 } |
316 | 317 |
317 TEST_F(JSONParserTest, DecodeUnicodeNonCharacter) { | 318 TEST_F(JSONParserTest, DecodeUnicodeNonCharacter) { |
318 // Tests Unicode code points (encoded as escaped UTF-16) that are not valid | 319 // Tests Unicode code points (encoded as escaped UTF-16) that are not valid |
319 // characters. | 320 // characters. |
320 EXPECT_FALSE(JSONReader::Read("[\"\\ufdd0\"]")); | 321 EXPECT_FALSE(JSONReader::Read("[\"\\ufdd0\"]")); |
321 EXPECT_FALSE(JSONReader::Read("[\"\\ufffe\"]")); | 322 EXPECT_FALSE(JSONReader::Read("[\"\\ufffe\"]")); |
322 EXPECT_FALSE(JSONReader::Read("[\"\\ud83f\\udffe\"]")); | 323 EXPECT_FALSE(JSONReader::Read("[\"\\ud83f\\udffe\"]")); |
323 } | 324 } |
324 | 325 |
325 } // namespace internal | 326 } // namespace internal |
326 } // namespace base | 327 } // namespace base |
OLD | NEW |