1 // Copyright 2014 The Chromium Authors
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/trace_event/traced_value.h"
6
7 #include <cmath>
8 #include <cstddef>
9 #include <utility>
10
11 #include "base/strings/string_util.h"
12 #include "base/values.h"
13 #include "testing/gtest/include/gtest/gtest.h"
14
15 namespace base {
16 namespace trace_event {
17
TEST(TraceEventArgumentTest,InitializerListCreatedContainers)18 TEST(TraceEventArgumentTest, InitializerListCreatedContainers) {
19 std::string json;
20 TracedValue::Build(
21 {
22 {"empty_array", TracedValue::Array({})},
23 {"empty_dictionary", TracedValue::Dictionary({})},
24 {"nested_array", TracedValue::Array({
25 TracedValue::Array({}),
26 TracedValue::Dictionary({}),
27 true,
28 })},
29 {"nested_dictionary", TracedValue::Dictionary({
30 {"d", TracedValue::Dictionary({})},
31 {"a", TracedValue::Array({})},
32 {"b", true},
33 })},
34 })
35 ->AppendAsTraceFormat(&json);
36 EXPECT_EQ(
37 "{\"empty_array\":[],\"empty_dictionary\":{},"
38 "\"nested_array\":[[],{},true],"
39 "\"nested_dictionary\":{\"d\":{},\"a\":[],\"b\":true}}",
40 json);
41 }
42
TEST(TraceEventArgumentTest,InitializerListCreatedFlatDictionary)43 TEST(TraceEventArgumentTest, InitializerListCreatedFlatDictionary) {
44 std::string json;
45 TracedValue::Build({{"bool_var", true},
46 {"double_var", 3.14},
47 {"int_var", 2020},
48 {"literal_var", "literal"}})
49 ->AppendAsTraceFormat(&json);
50 EXPECT_EQ(
51 "{\"bool_var\":true,\"double_var\":3.14,\"int_var\":2020,\""
52 "literal_var\":\"literal\"}",
53 json);
54 }
55
TEST(TraceEventArgumentTest,ArrayAndDictionaryScope)56 TEST(TraceEventArgumentTest, ArrayAndDictionaryScope) {
57 std::unique_ptr<TracedValue> value(new TracedValue());
58 {
59 auto dictionary = value->BeginDictionaryScoped("dictionary_name");
60 value->SetInteger("my_int", 1);
61 }
62 {
63 auto array = value->BeginArrayScoped("array_name");
64 value->AppendInteger(2);
65 }
66 {
67 auto surround_dictionary =
68 value->BeginDictionaryScoped("outside_dictionary");
69 value->SetBoolean("my_bool", true);
70 {
71 auto inside_array = value->BeginArrayScoped("inside_array");
72 value->AppendBoolean(false);
73 }
74 {
75 auto inside_array = value->BeginDictionaryScoped("inside_dictionary");
76 value->SetBoolean("inner_bool", false);
77 }
78 }
79 {
80 auto surround_array = value->BeginArrayScoped("outside_array");
81 value->AppendBoolean(false);
82 {
83 auto inside_dictionary = value->AppendDictionaryScoped();
84 value->SetBoolean("my_bool", true);
85 }
86 {
87 auto inside_array = value->AppendArrayScoped();
88 value->AppendBoolean(false);
89 }
90 }
91 {
92 auto dictionary = value->BeginDictionaryScopedWithCopiedName(
93 std::string("wonderful_") + std::string("world"));
94 }
95 {
96 auto array = value->BeginArrayScopedWithCopiedName(
97 std::string("wonderful_") + std::string("array"));
98 }
99 std::string json;
100 value->AppendAsTraceFormat(&json);
101 EXPECT_EQ(
102 "{"
103 "\"dictionary_name\":{\"my_int\":1},"
104 "\"array_name\":[2],"
105 "\"outside_dictionary\":{\"my_bool\":true,\"inside_array\":[false],"
106 "\"inside_dictionary\":{\"inner_bool\":false}},"
107 "\"outside_array\":[false,{\"my_bool\":true},[false]],"
108 "\"wonderful_world\":{},"
109 "\"wonderful_array\":[]"
110 "}",
111 json);
112 }
113
SayHello()114 std::string SayHello() {
115 // Create a string by concatenating two strings, so that there is no literal
116 // corresponding to the result.
117 return std::string("hello ") + std::string("world");
118 }
119
TEST(TraceEventArgumentTest,StringAndPointerConstructors)120 TEST(TraceEventArgumentTest, StringAndPointerConstructors) {
121 std::string json;
122 const char* const_char_ptr_var = "const char* value";
123 TracedValue::Build(
124 {
125 {"literal_var", "literal"},
126 {"std_string_var", std::string("std::string value")},
127 {"string_from_function", SayHello()},
128 {"string_from_lambda", []() { return std::string("hello"); }()},
129 {"base_string_piece_var",
130 base::StringPiece("base::StringPiece value")},
131 {"const_char_ptr_var", const_char_ptr_var},
132 {"void_nullptr", static_cast<void*>(nullptr)},
133 {"int_nullptr", static_cast<int*>(nullptr)},
134 {"void_1234ptr", reinterpret_cast<void*>(0x1234)},
135 })
136 ->AppendAsTraceFormat(&json);
137 EXPECT_EQ(
138 "{\"literal_var\":\"literal\","
139 "\"std_string_var\":\"std::string value\","
140 "\"string_from_function\":\"hello world\","
141 "\"string_from_lambda\":\"hello\","
142 "\"base_string_piece_var\":\"base::StringPiece value\","
143 "\"const_char_ptr_var\":\"const char* value\","
144 "\"void_nullptr\":\"0x0\","
145 "\"int_nullptr\":\"0x0\","
146 "\"void_1234ptr\":\"0x1234\"}",
147 json);
148 }
149
TEST(TraceEventArgumentTest,FlatDictionary)150 TEST(TraceEventArgumentTest, FlatDictionary) {
151 std::unique_ptr<TracedValue> value(new TracedValue());
152 value->SetBoolean("bool", true);
153 value->SetDouble("double", 0.0);
154 value->SetInteger("int", 2014);
155 value->SetString("string", "string");
156 value->SetPointer("ptr", reinterpret_cast<void*>(0x1234));
157 std::string json = "PREFIX";
158 value->AppendAsTraceFormat(&json);
159 EXPECT_EQ(
160 "PREFIX{\"bool\":true,\"double\":0.0,\"int\":2014,\"string\":\"string\","
161 "\"ptr\":\"0x1234\"}",
162 json);
163 }
164
TEST(TraceEventArgumentTest,NoDotPathExpansion)165 TEST(TraceEventArgumentTest, NoDotPathExpansion) {
166 std::unique_ptr<TracedValue> value(new TracedValue());
167 value->SetBoolean("bo.ol", true);
168 value->SetDouble("doub.le", 0.0);
169 value->SetInteger("in.t", 2014);
170 value->SetString("str.ing", "str.ing");
171 std::string json;
172 value->AppendAsTraceFormat(&json);
173 EXPECT_EQ(
174 "{\"bo.ol\":true,\"doub.le\":0.0,\"in.t\":2014,\"str.ing\":\"str.ing\"}",
175 json);
176 }
177
TEST(TraceEventArgumentTest,Hierarchy)178 TEST(TraceEventArgumentTest, Hierarchy) {
179 std::unique_ptr<TracedValue> value(new TracedValue());
180 value->BeginArray("a1");
181 value->AppendInteger(1);
182 value->AppendBoolean(true);
183 value->BeginDictionary();
184 value->SetInteger("i2", 3);
185 value->EndDictionary();
186 value->EndArray();
187 value->SetBoolean("b0", true);
188 value->SetDouble("d0", 0.0);
189 value->BeginDictionary("dict1");
190 value->BeginDictionary("dict2");
191 value->SetBoolean("b2", false);
192 value->EndDictionary();
193 value->SetInteger("i1", 2014);
194 value->SetString("s1", "foo");
195 value->EndDictionary();
196 value->SetInteger("i0", 2014);
197 value->SetString("s0", "foo");
198 std::string json;
199 value->AppendAsTraceFormat(&json);
200 EXPECT_EQ(
201 "{\"a1\":[1,true,{\"i2\":3}],\"b0\":true,\"d0\":0.0,\"dict1\":{\"dict2\":"
202 "{\"b2\":false},\"i1\":2014,\"s1\":\"foo\"},\"i0\":2014,\"s0\":"
203 "\"foo\"}",
204 json);
205 }
206
TEST(TraceEventArgumentTest,LongStrings)207 TEST(TraceEventArgumentTest, LongStrings) {
208 std::string kLongString = "supercalifragilisticexpialidocious";
209 std::string kLongString2 = "0123456789012345678901234567890123456789";
210 char kLongString3[4096];
211 for (size_t i = 0; i < sizeof(kLongString3); ++i)
212 kLongString3[i] = 'a' + (i % 25);
213 kLongString3[sizeof(kLongString3) - 1] = '\0';
214
215 std::unique_ptr<TracedValue> value(new TracedValue());
216 value->SetString("a", "short");
217 value->SetString("b", kLongString);
218 value->BeginArray("c");
219 value->AppendString(kLongString2);
220 value->AppendString("");
221 value->BeginDictionary();
222 value->SetString("a", kLongString3);
223 value->EndDictionary();
224 value->EndArray();
225
226 std::string json;
227 value->AppendAsTraceFormat(&json);
228 EXPECT_EQ("{\"a\":\"short\",\"b\":\"" + kLongString + "\",\"c\":[\"" +
229 kLongString2 + "\",\"\",{\"a\":\"" + kLongString3 + "\"}]}",
230 json);
231 }
232
TEST(TraceEventArgumentTest,PassTracedValue)233 TEST(TraceEventArgumentTest, PassTracedValue) {
234 auto dict_value = std::make_unique<TracedValue>();
235 dict_value->SetInteger("a", 1);
236
237 auto nested_dict_value = std::make_unique<TracedValue>();
238 nested_dict_value->SetInteger("b", 2);
239 nested_dict_value->BeginArray("c");
240 nested_dict_value->AppendString("foo");
241 nested_dict_value->EndArray();
242
243 dict_value->SetValue("e", nested_dict_value.get());
244
245 // Check the merged result.
246 std::string json;
247 dict_value->AppendAsTraceFormat(&json);
248 EXPECT_EQ("{\"a\":1,\"e\":{\"b\":2,\"c\":[\"foo\"]}}", json);
249
250 // Check that the passed nestd dict was left unouthced.
251 json = "";
252 nested_dict_value->AppendAsTraceFormat(&json);
253 EXPECT_EQ("{\"b\":2,\"c\":[\"foo\"]}", json);
254
255 // And that it is still usable.
256 nested_dict_value->SetInteger("f", 3);
257 nested_dict_value->BeginDictionary("g");
258 nested_dict_value->EndDictionary();
259 json = "";
260 nested_dict_value->AppendAsTraceFormat(&json);
261 EXPECT_EQ("{\"b\":2,\"c\":[\"foo\"],\"f\":3,\"g\":{}}", json);
262 }
263
TEST(TraceEventArgumentTest,NanAndInfinityJSON)264 TEST(TraceEventArgumentTest, NanAndInfinityJSON) {
265 TracedValueJSON value;
266 value.SetDouble("nan", std::nan(""));
267 value.SetDouble("infinity", INFINITY);
268 value.SetDouble("negInfinity", -INFINITY);
269 std::string json;
270 value.AppendAsTraceFormat(&json);
271 EXPECT_EQ(
272 "{\"nan\":\"NaN\",\"infinity\":\"Infinity\","
273 "\"negInfinity\":\"-Infinity\"}",
274 json);
275
276 std::string formatted_json = value.ToFormattedJSON();
277 // Remove CR and LF to make the result platform-independent.
278 ReplaceChars(formatted_json, "\n\r", "", &formatted_json);
279 EXPECT_EQ(
280 "{"
281 " \"infinity\": \"Infinity\","
282 " \"nan\": \"NaN\","
283 " \"negInfinity\": \"-Infinity\""
284 "}",
285 formatted_json);
286 }
287
288 } // namespace trace_event
289 } // namespace base
290