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