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 : List* l = ValueGetList(&v);
34 E : EXPECT_EQ(Value_Type_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, LeafSetInt) {
81 E : Value v;
82 E : Leaf* l = ValueGetLeaf(&v);
83 :
84 E : LeafSetInt(42, l);
85 E : EXPECT_EQ(Leaf_Type_INTEGER, l->type());
86 E : EXPECT_EQ(42, l->integer());
87 :
88 E : EXPECT_TRUE(l->has_integer());
89 E : EXPECT_FALSE(l->has_unsigned_integer());
90 E : EXPECT_FALSE(l->has_real());
91 E : EXPECT_FALSE(l->has_string());
92 E : EXPECT_FALSE(l->has_address());
93 E : EXPECT_FALSE(l->has_stack_trace());
94 E : EXPECT_FALSE(l->has_blob());
95 E : }
96 :
97 E : TEST(CrashDataTest, LeafSetUInt) {
98 E : Value v;
99 E : Leaf* l = ValueGetLeaf(&v);
100 :
101 E : LeafSetUInt(42, l);
102 E : EXPECT_EQ(Leaf_Type_UNSIGNED_INTEGER, l->type());
103 E : EXPECT_EQ(42, l->unsigned_integer());
104 :
105 E : EXPECT_FALSE(l->has_integer());
106 E : EXPECT_TRUE(l->has_unsigned_integer());
107 E : EXPECT_FALSE(l->has_real());
108 E : EXPECT_FALSE(l->has_string());
109 E : EXPECT_FALSE(l->has_address());
110 E : EXPECT_FALSE(l->has_stack_trace());
111 E : EXPECT_FALSE(l->has_blob());
112 E : }
113 :
114 E : TEST(CrashDataTest, LeafSetReal) {
115 E : Value v;
116 E : Leaf* l = ValueGetLeaf(&v);
117 :
118 E : LeafSetReal(0.2, l);
119 E : EXPECT_EQ(Leaf_Type_REAL, l->type());
120 E : EXPECT_EQ(0.2, l->real());
121 :
122 E : EXPECT_FALSE(l->has_integer());
123 E : EXPECT_FALSE(l->has_unsigned_integer());
124 E : EXPECT_TRUE(l->has_real());
125 E : EXPECT_FALSE(l->has_string());
126 E : EXPECT_FALSE(l->has_address());
127 E : EXPECT_FALSE(l->has_stack_trace());
128 E : EXPECT_FALSE(l->has_blob());
129 E : }
130 :
131 E : TEST(CrashDataTest, LeafGetString) {
132 E : Value v;
133 E : Leaf* l = ValueGetLeaf(&v);
134 :
135 E : std::string* s = LeafGetString(l);
136 E : EXPECT_EQ(Leaf_Type_STRING, l->type());
137 E : EXPECT_EQ(s, l->mutable_string());
138 :
139 E : EXPECT_FALSE(l->has_integer());
140 E : EXPECT_FALSE(l->has_unsigned_integer());
141 E : EXPECT_FALSE(l->has_real());
142 E : EXPECT_TRUE(l->has_string());
143 E : EXPECT_FALSE(l->has_address());
144 E : EXPECT_FALSE(l->has_stack_trace());
145 E : EXPECT_FALSE(l->has_blob());
146 E : }
147 :
148 E : TEST(CrashDataTest, LeafGetAddress) {
149 E : Value v;
150 E : Leaf* l = ValueGetLeaf(&v);
151 :
152 E : Address* a = LeafGetAddress(l);
153 E : EXPECT_EQ(Leaf_Type_ADDRESS, l->type());
154 E : EXPECT_EQ(a, l->mutable_address());
155 :
156 E : EXPECT_FALSE(l->has_integer());
157 E : EXPECT_FALSE(l->has_unsigned_integer());
158 E : EXPECT_FALSE(l->has_real());
159 E : EXPECT_FALSE(l->has_string());
160 E : EXPECT_TRUE(l->has_address());
161 E : EXPECT_FALSE(l->has_stack_trace());
162 E : EXPECT_FALSE(l->has_blob());
163 E : }
164 :
165 E : TEST(CrashDataTest, LeafGetStackTrace) {
166 E : Value v;
167 E : Leaf* l = ValueGetLeaf(&v);
168 :
169 E : StackTrace* st = LeafGetStackTrace(l);
170 E : EXPECT_EQ(Leaf_Type_STACK_TRACE, l->type());
171 E : EXPECT_EQ(st, l->mutable_stack_trace());
172 :
173 E : EXPECT_FALSE(l->has_integer());
174 E : EXPECT_FALSE(l->has_unsigned_integer());
175 E : EXPECT_FALSE(l->has_real());
176 E : EXPECT_FALSE(l->has_string());
177 E : EXPECT_FALSE(l->has_address());
178 E : EXPECT_TRUE(l->has_stack_trace());
179 E : EXPECT_FALSE(l->has_blob());
180 E : }
181 :
182 E : TEST(CrashDataTest, LeafGetBlob) {
183 E : Value v;
184 E : Leaf* l = ValueGetLeaf(&v);
185 :
186 E : Blob* b = LeafGetBlob(l);
187 E : EXPECT_EQ(Leaf_Type_BLOB, l->type());
188 E : EXPECT_EQ(b, l->mutable_blob());
189 :
190 E : EXPECT_FALSE(l->has_integer());
191 E : EXPECT_FALSE(l->has_unsigned_integer());
192 E : EXPECT_FALSE(l->has_real());
193 E : EXPECT_FALSE(l->has_string());
194 E : EXPECT_FALSE(l->has_address());
195 E : EXPECT_FALSE(l->has_stack_trace());
196 E : EXPECT_TRUE(l->has_blob());
197 E : }
198 :
199 : } // namespace crashdata
|