1 : // Copyright 2015 Google Inc. All Rights Reserved.
2 : //
3 : // Licensed under the Apache License, Version 2.0 (the "License");
4 : // you may not use this file except in compliance with the License.
5 : // You may obtain a copy of the License at
6 : //
7 : // http://www.apache.org/licenses/LICENSE-2.0
8 : //
9 : // Unless required by applicable law or agreed to in writing, software
10 : // distributed under the License is distributed on an "AS IS" BASIS,
11 : // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 : // See the License for the specific language governing permissions and
13 : // limitations under the License.
14 :
15 : #include "syzygy/crashdata/crashdata.h"
16 :
17 : #include "gtest/gtest.h"
18 :
19 : namespace crashdata {
20 :
21 E : TEST(CrashDataTest, ValueGetLeaf) {
22 E : Value v;
23 E : Leaf* l = ValueGetLeaf(&v);
24 E : EXPECT_EQ(Value_Type_LEAF, v.type());
25 E : EXPECT_TRUE(v.has_leaf());
26 E : EXPECT_FALSE(v.has_list());
27 E : EXPECT_FALSE(v.has_dictionary());
28 E : EXPECT_EQ(l, v.mutable_leaf());
29 E : }
30 :
31 E : TEST(CrashDataTest, ValueGetList) {
32 E : Value v;
33 E : ValueList* l = ValueGetValueList(&v);
34 E : EXPECT_EQ(Value_Type_VALUE_LIST, v.type());
35 E : EXPECT_FALSE(v.has_leaf());
36 E : EXPECT_TRUE(v.has_list());
37 E : EXPECT_FALSE(v.has_dictionary());
38 E : EXPECT_EQ(l, v.mutable_list());
39 E : }
40 :
41 E : TEST(CrashDataTest, ValueGetDict) {
42 E : Value v;
43 E : Dictionary* d = ValueGetDict(&v);
44 E : EXPECT_EQ(Value_Type_DICTIONARY, v.type());
45 E : EXPECT_FALSE(v.has_leaf());
46 E : EXPECT_FALSE(v.has_list());
47 E : EXPECT_TRUE(v.has_dictionary());
48 E : EXPECT_EQ(d, v.mutable_dictionary());
49 E : }
50 :
51 E : TEST(CrashDataTest, DictAddValue) {
52 E : Value v;
53 E : Dictionary* d = ValueGetDict(&v);
54 E : EXPECT_EQ(0u, d->values_size());
55 :
56 E : std::string key("key");
57 E : Value* v1 = DictAddValue(key, d);
58 :
59 E : EXPECT_EQ(1u, d->values_size());
60 E : const KeyValue& kv = d->values().Get(0);
61 E : EXPECT_EQ(key, kv.key());
62 E : EXPECT_EQ(v1, &kv.value());
63 E : }
64 :
65 E : TEST(CrashDataTest, DictAddLeaf) {
66 E : Value v;
67 E : Dictionary* d = ValueGetDict(&v);
68 E : EXPECT_EQ(0u, d->values_size());
69 :
70 E : std::string key("key");
71 E : Leaf* l = DictAddLeaf(key, d);
72 :
73 E : EXPECT_EQ(1u, d->values_size());
74 E : const KeyValue& kv = d->values().Get(0);
75 E : EXPECT_EQ(key, kv.key());
76 E : EXPECT_EQ(Value_Type_LEAF, kv.value().type());
77 E : EXPECT_EQ(l, &kv.value().leaf());
78 E : }
79 :
80 E : TEST(CrashDataTest, DictAddDict) {
81 E : Value v;
82 E : Dictionary* d = ValueGetDict(&v);
83 E : EXPECT_EQ(0u, d->values_size());
84 :
85 E : std::string key("key");
86 E : Dictionary* dict = DictAddDict(key, d);
87 :
88 E : EXPECT_EQ(1u, d->values_size());
89 E : const KeyValue& kv = d->values().Get(0);
90 E : EXPECT_EQ(key, kv.key());
91 E : EXPECT_EQ(Value_Type_DICTIONARY, kv.value().type());
92 E : EXPECT_EQ(dict, &kv.value().dictionary());
93 E : }
94 :
95 E : TEST(CrashDataTest, LeafSetInt) {
96 E : Value v;
97 E : Leaf* l = ValueGetLeaf(&v);
98 :
99 E : LeafSetInt(42, l);
100 E : EXPECT_EQ(Leaf_Type_INTEGER, l->type());
101 E : EXPECT_EQ(42, l->integer());
102 :
103 E : EXPECT_TRUE(l->has_integer());
104 E : EXPECT_FALSE(l->has_unsigned_integer());
105 E : EXPECT_FALSE(l->has_real());
106 E : EXPECT_FALSE(l->has_string());
107 E : EXPECT_FALSE(l->has_address());
108 E : EXPECT_FALSE(l->has_stack_trace());
109 E : EXPECT_FALSE(l->has_blob());
110 E : }
111 :
112 E : TEST(CrashDataTest, LeafSetUInt) {
113 E : Value v;
114 E : Leaf* l = ValueGetLeaf(&v);
115 :
116 E : LeafSetUInt(42, l);
117 E : EXPECT_EQ(Leaf_Type_UNSIGNED_INTEGER, l->type());
118 E : EXPECT_EQ(42, l->unsigned_integer());
119 :
120 E : EXPECT_FALSE(l->has_integer());
121 E : EXPECT_TRUE(l->has_unsigned_integer());
122 E : EXPECT_FALSE(l->has_real());
123 E : EXPECT_FALSE(l->has_string());
124 E : EXPECT_FALSE(l->has_address());
125 E : EXPECT_FALSE(l->has_stack_trace());
126 E : EXPECT_FALSE(l->has_blob());
127 E : }
128 :
129 E : TEST(CrashDataTest, LeafSetReal) {
130 E : Value v;
131 E : Leaf* l = ValueGetLeaf(&v);
132 :
133 E : LeafSetReal(0.2, l);
134 E : EXPECT_EQ(Leaf_Type_REAL, l->type());
135 E : EXPECT_EQ(0.2, l->real());
136 :
137 E : EXPECT_FALSE(l->has_integer());
138 E : EXPECT_FALSE(l->has_unsigned_integer());
139 E : EXPECT_TRUE(l->has_real());
140 E : EXPECT_FALSE(l->has_string());
141 E : EXPECT_FALSE(l->has_address());
142 E : EXPECT_FALSE(l->has_stack_trace());
143 E : EXPECT_FALSE(l->has_blob());
144 E : }
145 :
146 E : TEST(CrashDataTest, LeafGetString) {
147 E : Value v;
148 E : Leaf* l = ValueGetLeaf(&v);
149 :
150 E : std::string* s = LeafGetString(l);
151 E : EXPECT_EQ(Leaf_Type_STRING, l->type());
152 E : EXPECT_EQ(s, l->mutable_string());
153 :
154 E : EXPECT_FALSE(l->has_integer());
155 E : EXPECT_FALSE(l->has_unsigned_integer());
156 E : EXPECT_FALSE(l->has_real());
157 E : EXPECT_TRUE(l->has_string());
158 E : EXPECT_FALSE(l->has_address());
159 E : EXPECT_FALSE(l->has_stack_trace());
160 E : EXPECT_FALSE(l->has_blob());
161 E : }
162 :
163 E : TEST(CrashDataTest, LeafGetAddress) {
164 E : Value v;
165 E : Leaf* l = ValueGetLeaf(&v);
166 :
167 E : Address* a = LeafGetAddress(l);
168 E : EXPECT_EQ(Leaf_Type_ADDRESS, l->type());
169 E : EXPECT_EQ(a, l->mutable_address());
170 :
171 E : EXPECT_FALSE(l->has_integer());
172 E : EXPECT_FALSE(l->has_unsigned_integer());
173 E : EXPECT_FALSE(l->has_real());
174 E : EXPECT_FALSE(l->has_string());
175 E : EXPECT_TRUE(l->has_address());
176 E : EXPECT_FALSE(l->has_stack_trace());
177 E : EXPECT_FALSE(l->has_blob());
178 E : }
179 :
180 E : TEST(CrashDataTest, LeafGetStackTrace) {
181 E : Value v;
182 E : Leaf* l = ValueGetLeaf(&v);
183 :
184 E : StackTrace* st = LeafGetStackTrace(l);
185 E : EXPECT_EQ(Leaf_Type_STACK_TRACE, l->type());
186 E : EXPECT_EQ(st, l->mutable_stack_trace());
187 :
188 E : EXPECT_FALSE(l->has_integer());
189 E : EXPECT_FALSE(l->has_unsigned_integer());
190 E : EXPECT_FALSE(l->has_real());
191 E : EXPECT_FALSE(l->has_string());
192 E : EXPECT_FALSE(l->has_address());
193 E : EXPECT_TRUE(l->has_stack_trace());
194 E : EXPECT_FALSE(l->has_blob());
195 E : }
196 :
197 E : TEST(CrashDataTest, LeafGetBlob) {
198 E : Value v;
199 E : Leaf* l = ValueGetLeaf(&v);
200 :
201 E : Blob* b = LeafGetBlob(l);
202 E : EXPECT_EQ(Leaf_Type_BLOB, l->type());
203 E : EXPECT_EQ(b, l->mutable_blob());
204 :
205 E : EXPECT_FALSE(l->has_integer());
206 E : EXPECT_FALSE(l->has_unsigned_integer());
207 E : EXPECT_FALSE(l->has_real());
208 E : EXPECT_FALSE(l->has_string());
209 E : EXPECT_FALSE(l->has_address());
210 E : EXPECT_FALSE(l->has_stack_trace());
211 E : EXPECT_TRUE(l->has_blob());
212 E : }
213 :
214 : } // namespace crashdata
|