1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/macros.h"
#include "components/invalidation/impl/object_id_invalidation_map_test_util.h"
#include <algorithm>
namespace syncer {
using ::testing::MakeMatcher;
using ::testing::MatchResultListener;
using ::testing::Matcher;
using ::testing::MatcherInterface;
using ::testing::PrintToString;
namespace {
class ObjectIdInvalidationMapEqMatcher
: public MatcherInterface<const ObjectIdInvalidationMap&> {
public:
explicit ObjectIdInvalidationMapEqMatcher(
const ObjectIdInvalidationMap& expected);
virtual bool MatchAndExplain(const ObjectIdInvalidationMap& lhs,
MatchResultListener* listener) const;
virtual void DescribeTo(::std::ostream* os) const;
virtual void DescribeNegationTo(::std::ostream* os) const;
private:
const ObjectIdInvalidationMap expected_;
DISALLOW_COPY_AND_ASSIGN(ObjectIdInvalidationMapEqMatcher);
};
ObjectIdInvalidationMapEqMatcher::ObjectIdInvalidationMapEqMatcher(
const ObjectIdInvalidationMap& expected) : expected_(expected) {
}
struct InvalidationEqPredicate {
InvalidationEqPredicate(const Invalidation& inv1)
: inv1_(inv1) { }
bool operator()(const Invalidation& inv2) {
return inv1_.Equals(inv2);
}
const Invalidation& inv1_;
};
bool ObjectIdInvalidationMapEqMatcher::MatchAndExplain(
const ObjectIdInvalidationMap& actual,
MatchResultListener* listener) const {
std::vector<syncer::Invalidation> expected_invalidations;
std::vector<syncer::Invalidation> actual_invalidations;
expected_.GetAllInvalidations(&expected_invalidations);
actual.GetAllInvalidations(&actual_invalidations);
std::vector<syncer::Invalidation> expected_only;
std::vector<syncer::Invalidation> actual_only;
for (std::vector<syncer::Invalidation>::iterator it =
expected_invalidations.begin();
it != expected_invalidations.end(); ++it) {
if (std::find_if(actual_invalidations.begin(),
actual_invalidations.end(),
InvalidationEqPredicate(*it))
== actual_invalidations.end()) {
expected_only.push_back(*it);
}
}
for (std::vector<syncer::Invalidation>::iterator it =
actual_invalidations.begin();
it != actual_invalidations.end(); ++it) {
if (std::find_if(expected_invalidations.begin(),
expected_invalidations.end(),
InvalidationEqPredicate(*it))
== expected_invalidations.end()) {
actual_only.push_back(*it);
}
}
if (expected_only.empty() && actual_only.empty())
return true;
bool printed_header = false;
if (!actual_only.empty()) {
*listener << " which has these unexpected elements: "
<< PrintToString(actual_only);
printed_header = true;
}
if (!expected_only.empty()) {
*listener << (printed_header ? ",\nand" : "which")
<< " doesn't have these expected elements: "
<< PrintToString(expected_only);
printed_header = true;
}
return false;
}
void ObjectIdInvalidationMapEqMatcher::DescribeTo(::std::ostream* os) const {
*os << " is equal to " << PrintToString(expected_);
}
void ObjectIdInvalidationMapEqMatcher::DescribeNegationTo(
::std::ostream* os) const {
*os << " isn't equal to " << PrintToString(expected_);
}
} // namespace
Matcher<const ObjectIdInvalidationMap&> Eq(
const ObjectIdInvalidationMap& expected) {
return MakeMatcher(new ObjectIdInvalidationMapEqMatcher(expected));
}
} // namespace syncer
|
