1 // Copyright 2015 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 <vector>
6
7 #include "base/files/file_util.h"
8 #include "base/values.h"
9 #include "chromecast/base/scoped_temp_file.h"
10 #include "chromecast/base/serializers.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12
13 namespace chromecast {
14 namespace {
15 const char kEmptyJsonString[] = "{}";
16 const char kEmptyJsonFileString[] = "{\n\n}\n";
17 const char kProperJsonString[] =
18 "{\n"
19 " \"compound\": {\n"
20 " \"a\": 1,\n"
21 " \"b\": 2\n"
22 " },\n"
23 " \"some_String\": \"1337\",\n"
24 " \"some_int\": 42,\n"
25 " \"the_list\": [ \"val1\", \"val2\" ]\n"
26 "}\n";
27 const char kPoorlyFormedJsonString[] = "{\"key\":";
28 const char kTestKey[] = "test_key";
29 const char kTestValue[] = "test_value";
30
31 } // namespace
32
TEST(DeserializeFromJson,EmptyString)33 TEST(DeserializeFromJson, EmptyString) {
34 std::string str;
35 std::unique_ptr<base::Value> value = DeserializeFromJson(str);
36 EXPECT_EQ(nullptr, value.get());
37 }
38
TEST(DeserializeFromJson,EmptyJsonObject)39 TEST(DeserializeFromJson, EmptyJsonObject) {
40 std::string str = kEmptyJsonString;
41 std::unique_ptr<base::Value> value = DeserializeFromJson(str);
42 EXPECT_NE(nullptr, value.get());
43 }
44
TEST(DeserializeFromJson,ProperJsonObject)45 TEST(DeserializeFromJson, ProperJsonObject) {
46 std::string str = kProperJsonString;
47 std::unique_ptr<base::Value> value = DeserializeFromJson(str);
48 EXPECT_NE(nullptr, value.get());
49 }
50
TEST(DeserializeFromJson,PoorlyFormedJsonObject)51 TEST(DeserializeFromJson, PoorlyFormedJsonObject) {
52 std::string str = kPoorlyFormedJsonString;
53 std::unique_ptr<base::Value> value = DeserializeFromJson(str);
54 EXPECT_EQ(nullptr, value.get());
55 }
56
TEST(SerializeToJson,BadValue)57 TEST(SerializeToJson, BadValue) {
58 base::Value value(std::vector<char>(12));
59 base::Optional<std::string> str = SerializeToJson(value);
60 EXPECT_FALSE(str.has_value());
61 }
62
TEST(SerializeToJson,EmptyValue)63 TEST(SerializeToJson, EmptyValue) {
64 base::DictionaryValue value;
65 base::Optional<std::string> str = SerializeToJson(value);
66 ASSERT_TRUE(str.has_value());
67 EXPECT_EQ(kEmptyJsonString, *str);
68 }
69
TEST(SerializeToJson,PopulatedValue)70 TEST(SerializeToJson, PopulatedValue) {
71 base::DictionaryValue orig_value;
72 orig_value.SetString(kTestKey, kTestValue);
73 base::Optional<std::string> str = SerializeToJson(orig_value);
74 ASSERT_TRUE(str.has_value());
75
76 std::unique_ptr<base::Value> new_value = DeserializeFromJson(*str);
77 ASSERT_NE(nullptr, new_value.get());
78 EXPECT_TRUE(new_value->Equals(&orig_value));
79 }
80
TEST(DeserializeJsonFromFile,NoFile)81 TEST(DeserializeJsonFromFile, NoFile) {
82 std::unique_ptr<base::Value> value =
83 DeserializeJsonFromFile(base::FilePath("/file/does/not/exist.json"));
84 EXPECT_EQ(nullptr, value.get());
85 }
86
TEST(DeserializeJsonFromFile,EmptyString)87 TEST(DeserializeJsonFromFile, EmptyString) {
88 ScopedTempFile temp;
89 EXPECT_EQ(static_cast<int>(strlen("")), temp.Write(""));
90 std::unique_ptr<base::Value> value = DeserializeJsonFromFile(temp.path());
91 EXPECT_EQ(nullptr, value.get());
92 }
93
TEST(DeserializeJsonFromFile,EmptyJsonObject)94 TEST(DeserializeJsonFromFile, EmptyJsonObject) {
95 ScopedTempFile temp;
96 EXPECT_EQ(static_cast<int>(strlen(kEmptyJsonString)),
97 temp.Write(kEmptyJsonString));
98 std::unique_ptr<base::Value> value = DeserializeJsonFromFile(temp.path());
99 EXPECT_NE(nullptr, value.get());
100 }
101
TEST(DeserializeJsonFromFile,ProperJsonObject)102 TEST(DeserializeJsonFromFile, ProperJsonObject) {
103 ScopedTempFile temp;
104 EXPECT_EQ(static_cast<int>(strlen(kProperJsonString)),
105 temp.Write(kProperJsonString));
106 std::unique_ptr<base::Value> value = DeserializeJsonFromFile(temp.path());
107 EXPECT_NE(nullptr, value.get());
108 }
109
TEST(DeserializeJsonFromFile,PoorlyFormedJsonObject)110 TEST(DeserializeJsonFromFile, PoorlyFormedJsonObject) {
111 ScopedTempFile temp;
112 EXPECT_EQ(static_cast<int>(strlen(kPoorlyFormedJsonString)),
113 temp.Write(kPoorlyFormedJsonString));
114 std::unique_ptr<base::Value> value = DeserializeJsonFromFile(temp.path());
115 EXPECT_EQ(nullptr, value.get());
116 }
117
TEST(SerializeJsonToFile,BadValue)118 TEST(SerializeJsonToFile, BadValue) {
119 ScopedTempFile temp;
120
121 base::Value value(std::vector<char>(12));
122 ASSERT_FALSE(SerializeJsonToFile(temp.path(), value));
123 std::string str(temp.Read());
124 EXPECT_TRUE(str.empty());
125 }
126
TEST(SerializeJsonToFile,EmptyValue)127 TEST(SerializeJsonToFile, EmptyValue) {
128 ScopedTempFile temp;
129
130 base::DictionaryValue value;
131 ASSERT_TRUE(SerializeJsonToFile(temp.path(), value));
132 std::string str(temp.Read());
133 ASSERT_FALSE(str.empty());
134 EXPECT_EQ(kEmptyJsonFileString, str);
135 }
136
TEST(SerializeJsonToFile,PopulatedValue)137 TEST(SerializeJsonToFile, PopulatedValue) {
138 ScopedTempFile temp;
139
140 base::DictionaryValue orig_value;
141 orig_value.SetString(kTestKey, kTestValue);
142 ASSERT_TRUE(SerializeJsonToFile(temp.path(), orig_value));
143 std::string str(temp.Read());
144 ASSERT_FALSE(str.empty());
145
146 std::unique_ptr<base::Value> new_value = DeserializeJsonFromFile(temp.path());
147 ASSERT_NE(nullptr, new_value.get());
148 EXPECT_TRUE(new_value->Equals(&orig_value));
149 }
150
151 } // namespace chromecast
152