1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// Copyright (c) 2012 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 <string>
#include "base/file_util.h"
#include "base/json/json_file_value_serializer.h"
#include "base/json/json_reader.h"
#include "base/json/json_string_value_serializer.h"
#include "base/memory/scoped_ptr.h"
#include "base/scoped_temp_dir.h"
#include "base/string_util.h"
#include "base/values.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace base {
namespace {
// Some proper JSON to test with:
const char kProperJSON[] =
"{\n"
" \"compound\": {\n"
" \"a\": 1,\n"
" \"b\": 2\n"
" },\n"
" \"some_String\": \"1337\",\n"
" \"some_int\": 42,\n"
" \"the_list\": [ \"val1\", \"val2\" ]\n"
"}\n";
// Some proper JSON with trailing commas:
const char kProperJSONWithCommas[] =
"{\n"
"\t\"some_int\": 42,\n"
"\t\"some_String\": \"1337\",\n"
"\t\"the_list\": [\"val1\", \"val2\", ],\n"
"\t\"compound\": { \"a\": 1, \"b\": 2, },\n"
"}\n";
const char kWinLineEnds[] = "\r\n";
const char kLinuxLineEnds[] = "\n";
// Verifies the generated JSON against the expected output.
void CheckJSONIsStillTheSame(Value& value) {
// Serialize back the output.
std::string serialized_json;
JSONStringValueSerializer str_serializer(&serialized_json);
str_serializer.set_pretty_print(true);
ASSERT_TRUE(str_serializer.Serialize(value));
// Unify line endings between platforms.
ReplaceSubstringsAfterOffset(&serialized_json, 0,
kWinLineEnds, kLinuxLineEnds);
// Now compare the input with the output.
ASSERT_EQ(kProperJSON, serialized_json);
}
// Test proper JSON [de]serialization from string is working.
TEST(JSONValueSerializerTest, ReadProperJSONFromString) {
// Try to deserialize it through the serializer.
std::string proper_json(kProperJSON);
JSONStringValueSerializer str_deserializer(proper_json);
int error_code = 0;
std::string error_message;
scoped_ptr<Value> value(
str_deserializer.Deserialize(&error_code, &error_message));
ASSERT_TRUE(value.get());
ASSERT_EQ(0, error_code);
ASSERT_TRUE(error_message.empty());
// Verify if the same JSON is still there.
CheckJSONIsStillTheSame(*value);
}
// Test that trialing commas are only properly deserialized from string when
// the proper flag for that is set.
TEST(JSONValueSerializerTest, ReadJSONWithTrailingCommasFromString) {
// Try to deserialize it through the serializer.
std::string proper_json(kProperJSONWithCommas);
JSONStringValueSerializer str_deserializer(proper_json);
int error_code = 0;
std::string error_message;
scoped_ptr<Value> value(
str_deserializer.Deserialize(&error_code, &error_message));
ASSERT_FALSE(value.get());
ASSERT_NE(0, error_code);
ASSERT_FALSE(error_message.empty());
// Now the flag is set and it must pass.
str_deserializer.set_allow_trailing_comma(true);
value.reset(str_deserializer.Deserialize(&error_code, &error_message));
ASSERT_TRUE(value.get());
ASSERT_EQ(JSONReader::JSON_TRAILING_COMMA, error_code);
// Verify if the same JSON is still there.
CheckJSONIsStillTheSame(*value);
}
// Test proper JSON [de]serialization from file is working.
TEST(JSONValueSerializerTest, ReadProperJSONFromFile) {
ScopedTempDir tempdir;
ASSERT_TRUE(tempdir.CreateUniqueTempDir());
// Write it down in the file.
FilePath temp_file(tempdir.path().AppendASCII("test.json"));
ASSERT_EQ(static_cast<int>(strlen(kProperJSON)),
file_util::WriteFile(temp_file, kProperJSON, strlen(kProperJSON)));
// Try to deserialize it through the serializer.
JSONFileValueSerializer file_deserializer(temp_file);
int error_code = 0;
std::string error_message;
scoped_ptr<Value> value(
file_deserializer.Deserialize(&error_code, &error_message));
ASSERT_TRUE(value.get());
ASSERT_EQ(0, error_code);
ASSERT_TRUE(error_message.empty());
// Verify if the same JSON is still there.
CheckJSONIsStillTheSame(*value);
}
// Test that trialing commas are only properly deserialized from file when
// the proper flag for that is set.
TEST(JSONValueSerializerTest, ReadJSONWithCommasFromFile) {
ScopedTempDir tempdir;
ASSERT_TRUE(tempdir.CreateUniqueTempDir());
// Write it down in the file.
FilePath temp_file(tempdir.path().AppendASCII("test.json"));
ASSERT_EQ(static_cast<int>(strlen(kProperJSONWithCommas)),
file_util::WriteFile(temp_file,
kProperJSONWithCommas,
strlen(kProperJSONWithCommas)));
// Try to deserialize it through the serializer.
JSONFileValueSerializer file_deserializer(temp_file);
// This must fail without the proper flag.
int error_code = 0;
std::string error_message;
scoped_ptr<Value> value(
file_deserializer.Deserialize(&error_code, &error_message));
ASSERT_FALSE(value.get());
ASSERT_NE(0, error_code);
ASSERT_FALSE(error_message.empty());
// Now the flag is set and it must pass.
file_deserializer.set_allow_trailing_comma(true);
value.reset(file_deserializer.Deserialize(&error_code, &error_message));
ASSERT_TRUE(value.get());
ASSERT_EQ(JSONReader::JSON_TRAILING_COMMA, error_code);
// Verify if the same JSON is still there.
CheckJSONIsStillTheSame(*value);
}
} // namespace
} // namespace base
|
