third_party/WebKit/Source/platform/TracedValueTest.cpp - Issue 2346663004: Moving platform tracing things into platform/tracing.

Side by Side Diff: third_party/WebKit/Source/platform/TracedValueTest.cpp

Issue 2346663004: Moving platform tracing things into platform/tracing. (Closed)

Patch Set: Created 4 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

« third_party/WebKit/Source/platform/MemoryCacheDumpProvider.h ('K') | « third_party/WebKit/Source/platform/TracedValue.cpp ('k') | third_party/WebKit/Source/platform/exported/Platform.cpp » ('j') | third_party/WebKit/Source/platform/tracing/TraceEvent.h » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 // Copyright 2014 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 "platform/TracedValue.h"

6

7 #include "base/json/json_reader.h"

8 #include "base/values.h"

9 #include "testing/gtest/include/gtest/gtest.h"

10 #include <memory>

11

12 namespace blink {

13

14 std::unique_ptr<base::Value> parseTracedValue(std::unique_ptr<TracedValue> value )

15 {

16 base::JSONReader reader;

17 CString utf8 = value->toString().utf8();

18 return reader.Read(utf8.data());

19 }

20

21 TEST(TracedValueTest, FlatDictionary)

22 {

23 std::unique_ptr<TracedValue> value = TracedValue::create();

24 value->setInteger("int", 2014);

25 value->setDouble("double", 0.0);

26 value->setBoolean("bool", true);

27 value->setString("string", "string");

28

29 std::unique_ptr<base::Value> parsed = parseTracedValue(std::move(value));

30 base::DictionaryValue* dictionary;

31 ASSERT_TRUE(parsed->GetAsDictionary(&dictionary));

32 int intValue;

33 EXPECT_TRUE(dictionary->GetInteger("int", &intValue));

34 EXPECT_EQ(2014, intValue);

35 double doubleValue;

36 EXPECT_TRUE(dictionary->GetDouble("double", &doubleValue));

37 EXPECT_EQ(0.0, doubleValue);

38 std::string stringValue;

39 EXPECT_TRUE(dictionary->GetString("string", &stringValue));

40 EXPECT_EQ("string", stringValue);

41 }

42

43 TEST(TracedValueTest, Hierarchy)

44 {

45 std::unique_ptr<TracedValue> value = TracedValue::create();

46 value->setInteger("i0", 2014);

47 value->beginDictionary("dict1");

48 value->setInteger("i1", 2014);

49 value->beginDictionary("dict2");

50 value->setBoolean("b2", false);

51 value->endDictionary();

52 value->setString("s1", "foo");

53 value->endDictionary();

54 value->setDouble("d0", 0.0);

55 value->setBoolean("b0", true);

56 value->beginArray("a1");

57 value->pushInteger(1);

58 value->pushBoolean(true);

59 value->beginDictionary();

60 value->setInteger("i2", 3);

61 value->endDictionary();

62 value->endArray();

63 value->setString("s0", "foo");

64

65 std::unique_ptr<base::Value> parsed = parseTracedValue(std::move(value));

66 base::DictionaryValue* dictionary;

67 ASSERT_TRUE(parsed->GetAsDictionary(&dictionary));

68 int i0;

69 EXPECT_TRUE(dictionary->GetInteger("i0", &i0));

70 EXPECT_EQ(2014, i0);

71 int i1;

72 EXPECT_TRUE(dictionary->GetInteger("dict1.i1", &i1));

73 EXPECT_EQ(2014, i1);

74 bool b2;

75 EXPECT_TRUE(dictionary->GetBoolean("dict1.dict2.b2", &b2));

76 EXPECT_FALSE(b2);

77 std::string s1;

78 EXPECT_TRUE(dictionary->GetString("dict1.s1", &s1));

79 EXPECT_EQ("foo", s1);

80 double d0;

81 EXPECT_TRUE(dictionary->GetDouble("d0", &d0));

82 EXPECT_EQ(0.0, d0);

83 bool b0;

84 EXPECT_TRUE(dictionary->GetBoolean("b0", &b0));

85 EXPECT_TRUE(b0);

86 base::ListValue* a1;

87 EXPECT_TRUE(dictionary->GetList("a1", &a1));

88 int a1i0;

89 EXPECT_TRUE(a1->GetInteger(0, &a1i0));

90 EXPECT_EQ(1, a1i0);

91 bool a1b1;

92 EXPECT_TRUE(a1->GetBoolean(1, &a1b1));

93 EXPECT_TRUE(a1b1);

94 base::DictionaryValue* a1d2;

95 EXPECT_TRUE(a1->GetDictionary(2, &a1d2));

96 int i2;

97 EXPECT_TRUE(a1d2->GetInteger("i2", &i2));

98 EXPECT_EQ(3, i2);

99 std::string s0;

100 EXPECT_TRUE(dictionary->GetString("s0", &s0));

101 EXPECT_EQ("foo", s0);

102 }

103

104 TEST(TracedValueTest, Escape)

105 {

106 std::unique_ptr<TracedValue> value = TracedValue::create();

107 value->setString("s0", "value0\\");

108 value->setString("s1", "value\n1");

109 value->setString("s2", "\"value2\"");

110 value->setString("s3\\", "value3");

111 value->setString("\"s4\"", "value4");

112

113 std::unique_ptr<base::Value> parsed = parseTracedValue(std::move(value));

114 base::DictionaryValue* dictionary;

115 ASSERT_TRUE(parsed->GetAsDictionary(&dictionary));

116 std::string s0;

117 EXPECT_TRUE(dictionary->GetString("s0", &s0));

118 EXPECT_EQ("value0\\", s0);

119 std::string s1;

120 EXPECT_TRUE(dictionary->GetString("s1", &s1));

121 EXPECT_EQ("value\n1", s1);

122 std::string s2;

123 EXPECT_TRUE(dictionary->GetString("s2", &s2));

124 EXPECT_EQ("\"value2\"", s2);

125 std::string s3;

126 EXPECT_TRUE(dictionary->GetString("s3\\", &s3));

127 EXPECT_EQ("value3", s3);

128 std::string s4;

129 EXPECT_TRUE(dictionary->GetString("\"s4\"", &s4));

130 EXPECT_EQ("value4", s4);

131 }

132

133 } // namespace blink

OLD	NEW