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

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

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

Patch Set: Created 4 years, 2 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:

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(

15 std::unique_ptr<TracedValue> value) {

16 base::JSONReader reader;

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

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

19 }

20

21 TEST(TracedValueTest, FlatDictionary) {

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

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

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

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

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

27

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

29 base::DictionaryValue* dictionary;

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

31 int intValue;

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

33 EXPECT_EQ(2014, intValue);

34 double doubleValue;

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

36 EXPECT_EQ(0.0, doubleValue);

37 std::string stringValue;

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

39 EXPECT_EQ("string", stringValue);

40 }

41

42 TEST(TracedValueTest, Hierarchy) {

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

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

45 value->beginDictionary("dict1");

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

47 value->beginDictionary("dict2");

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

49 value->endDictionary();

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

51 value->endDictionary();

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

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

54 value->beginArray("a1");

55 value->pushInteger(1);

56 value->pushBoolean(true);

57 value->beginDictionary();

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

59 value->endDictionary();

60 value->endArray();

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

62

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

64 base::DictionaryValue* dictionary;

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

66 int i0;

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

68 EXPECT_EQ(2014, i0);

69 int i1;

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

71 EXPECT_EQ(2014, i1);

72 bool b2;

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

74 EXPECT_FALSE(b2);

75 std::string s1;

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

77 EXPECT_EQ("foo", s1);

78 double d0;

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

80 EXPECT_EQ(0.0, d0);

81 bool b0;

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

83 EXPECT_TRUE(b0);

84 base::ListValue* a1;

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

86 int a1i0;

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

88 EXPECT_EQ(1, a1i0);

89 bool a1b1;

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

91 EXPECT_TRUE(a1b1);

92 base::DictionaryValue* a1d2;

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

94 int i2;

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

96 EXPECT_EQ(3, i2);

97 std::string s0;

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

99 EXPECT_EQ("foo", s0);

100 }

101

102 TEST(TracedValueTest, Escape) {

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

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

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

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

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

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

109

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

111 base::DictionaryValue* dictionary;

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

113 std::string s0;

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

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

116 std::string s1;

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

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

119 std::string s2;

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

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

122 std::string s3;

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

124 EXPECT_EQ("value3", s3);

125 std::string s4;

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

127 EXPECT_EQ("value4", s4);

128 }

129

130 } // namespace blink

OLD	NEW

« no previous file with comments | « third_party/WebKit/Source/platform/TracedValue.cpp ('k') | third_party/WebKit/Source/platform/exported/Platform.cpp » ('j') | no next file with comments »