1 // Copyright (c) 2013 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 "ppapi/shared_impl/unittest_utils.h"
6
7 #include <cmath>
8
9 #include "base/containers/hash_tables.h"
10 #include "base/logging.h"
11 #include "ipc/ipc_message.h"
12 #include "ppapi/shared_impl/array_var.h"
13 #include "ppapi/shared_impl/dictionary_var.h"
14 #include "ppapi/shared_impl/resource_var.h"
15 #include "ppapi/shared_impl/var.h"
16 #include "ppapi/shared_impl/var_tracker.h"
17
18 namespace ppapi {
19
20 namespace {
21
22 // When two vars x and y are found to be equal, an entry is inserted into
23 // |visited_map| with (x.value.as_id, y.value.as_id). This allows reference
24 // cycles to be avoided. It also allows us to associate nodes in |expected| with
25 // nodes in |actual| and check whether the graphs have equivalent topology.
Equals(const PP_Var & expected,const PP_Var & actual,bool test_string_references,base::hash_map<int64_t,int64_t> * visited_map)26 bool Equals(const PP_Var& expected,
27 const PP_Var& actual,
28 bool test_string_references,
29 base::hash_map<int64_t, int64_t>* visited_map) {
30 if (expected.type != actual.type) {
31 LOG(ERROR) << "expected type: " << expected.type
32 << " actual type: " << actual.type;
33 return false;
34 }
35 if (VarTracker::IsVarTypeRefcounted(expected.type)) {
36 base::hash_map<int64_t, int64_t>::iterator it =
37 visited_map->find(expected.value.as_id);
38 if (it != visited_map->end()) {
39 if (it->second != actual.value.as_id) {
40 LOG(ERROR) << "expected id: " << it->second
41 << " actual id: " << actual.value.as_id;
42 return false;
43 } else {
44 return true;
45 }
46 } else {
47 if (expected.type != PP_VARTYPE_STRING || test_string_references)
48 (*visited_map)[expected.value.as_id] = actual.value.as_id;
49 }
50 }
51 switch (expected.type) {
52 case PP_VARTYPE_UNDEFINED:
53 return true;
54 case PP_VARTYPE_NULL:
55 return true;
56 case PP_VARTYPE_BOOL:
57 if (expected.value.as_bool != actual.value.as_bool) {
58 LOG(ERROR) << "expected: " << expected.value.as_bool
59 << " actual: " << actual.value.as_bool;
60 return false;
61 }
62 return true;
63 case PP_VARTYPE_INT32:
64 if (expected.value.as_int != actual.value.as_int) {
65 LOG(ERROR) << "expected: " << expected.value.as_int
66 << " actual: " << actual.value.as_int;
67 return false;
68 }
69 return true;
70 case PP_VARTYPE_DOUBLE:
71 if (fabs(expected.value.as_double - actual.value.as_double) > 1.0e-4) {
72 LOG(ERROR) << "expected: " << expected.value.as_double
73 << " actual: " << actual.value.as_double;
74 return false;
75 }
76 return true;
77 case PP_VARTYPE_OBJECT:
78 if (expected.value.as_id != actual.value.as_id) {
79 LOG(ERROR) << "expected: " << expected.value.as_id
80 << " actual: " << actual.value.as_id;
81 return false;
82 }
83 return true;
84 case PP_VARTYPE_STRING: {
85 StringVar* expected_var = StringVar::FromPPVar(expected);
86 StringVar* actual_var = StringVar::FromPPVar(actual);
87 DCHECK(expected_var && actual_var);
88 if (expected_var->value() != actual_var->value()) {
89 LOG(ERROR) << "expected: " << expected_var->value()
90 << " actual: " << actual_var->value();
91 return false;
92 }
93 return true;
94 }
95 case PP_VARTYPE_ARRAY_BUFFER: {
96 ArrayBufferVar* expected_var = ArrayBufferVar::FromPPVar(expected);
97 ArrayBufferVar* actual_var = ArrayBufferVar::FromPPVar(actual);
98 DCHECK(expected_var && actual_var);
99 if (expected_var->ByteLength() != actual_var->ByteLength()) {
100 LOG(ERROR) << "expected: " << expected_var->ByteLength()
101 << " actual: " << actual_var->ByteLength();
102 return false;
103 }
104 if (memcmp(expected_var->Map(),
105 actual_var->Map(),
106 expected_var->ByteLength()) != 0) {
107 LOG(ERROR) << "expected array buffer does not match actual.";
108 return false;
109 }
110 return true;
111 }
112 case PP_VARTYPE_ARRAY: {
113 ArrayVar* expected_var = ArrayVar::FromPPVar(expected);
114 ArrayVar* actual_var = ArrayVar::FromPPVar(actual);
115 DCHECK(expected_var && actual_var);
116 if (expected_var->elements().size() != actual_var->elements().size()) {
117 LOG(ERROR) << "expected: " << expected_var->elements().size()
118 << " actual: " << actual_var->elements().size();
119 return false;
120 }
121 for (size_t i = 0; i < expected_var->elements().size(); ++i) {
122 if (!Equals(expected_var->elements()[i].get(),
123 actual_var->elements()[i].get(),
124 test_string_references,
125 visited_map)) {
126 return false;
127 }
128 }
129 return true;
130 }
131 case PP_VARTYPE_DICTIONARY: {
132 DictionaryVar* expected_var = DictionaryVar::FromPPVar(expected);
133 DictionaryVar* actual_var = DictionaryVar::FromPPVar(actual);
134 DCHECK(expected_var && actual_var);
135 if (expected_var->key_value_map().size() !=
136 actual_var->key_value_map().size()) {
137 LOG(ERROR) << "expected: " << expected_var->key_value_map().size()
138 << " actual: " << actual_var->key_value_map().size();
139 return false;
140 }
141 DictionaryVar::KeyValueMap::const_iterator expected_iter =
142 expected_var->key_value_map().begin();
143 DictionaryVar::KeyValueMap::const_iterator actual_iter =
144 actual_var->key_value_map().begin();
145 for (; expected_iter != expected_var->key_value_map().end();
146 ++expected_iter, ++actual_iter) {
147 if (expected_iter->first != actual_iter->first) {
148 LOG(ERROR) << "expected: " << expected_iter->first
149 << " actual: " << actual_iter->first;
150 return false;
151 }
152 if (!Equals(expected_iter->second.get(),
153 actual_iter->second.get(),
154 test_string_references,
155 visited_map)) {
156 return false;
157 }
158 }
159 return true;
160 }
161 case PP_VARTYPE_RESOURCE: {
162 ResourceVar* expected_var = ResourceVar::FromPPVar(expected);
163 ResourceVar* actual_var = ResourceVar::FromPPVar(actual);
164 DCHECK(expected_var && actual_var);
165 if (expected_var->GetPPResource() != actual_var->GetPPResource()) {
166 LOG(ERROR) << "expected: " << expected_var->GetPPResource()
167 << " actual: " << actual_var->GetPPResource();
168 return false;
169 }
170
171 const IPC::Message* actual_message = actual_var->GetCreationMessage();
172 const IPC::Message* expected_message = expected_var->GetCreationMessage();
173 if (expected_message->size() != actual_message->size()) {
174 LOG(ERROR) << "expected creation message size: "
175 << expected_message->size()
176 << " actual: " << actual_message->size();
177 return false;
178 }
179
180 // Set the upper 24 bits of actual creation_message flags to the same as
181 // expected. This is an unpredictable reference number that changes
182 // between serialization/deserialization, and we do not want it to cause
183 // the comparison to fail.
184 IPC::Message local_actual_message(*actual_message);
185 local_actual_message.SetHeaderValues(
186 actual_message->routing_id(),
187 actual_message->type(),
188 (expected_message->flags() & 0xffffff00) |
189 (actual_message->flags() & 0xff));
190 if (memcmp(expected_message->data(),
191 local_actual_message.data(),
192 expected_message->size()) != 0) {
193 LOG(ERROR) << "expected creation message does not match actual.";
194 return false;
195 }
196 return true;
197 }
198 }
199 NOTREACHED();
200 return false;
201 }
202
203 } // namespace
204
TestEqual(const PP_Var & expected,const PP_Var & actual,bool test_string_references)205 bool TestEqual(const PP_Var& expected,
206 const PP_Var& actual,
207 bool test_string_references) {
208 base::hash_map<int64_t, int64_t> visited_map;
209 return Equals(expected, actual, test_string_references, &visited_map);
210 }
211
212 } // namespace ppapi
213