/proc/self/cwd/external/com_google_googletest/googlemock/src/gmock-cardinalities.cc
Line | Count | Source (jump to first uncovered line) |
1 | | // Copyright 2007, Google Inc. |
2 | | // All rights reserved. |
3 | | // |
4 | | // Redistribution and use in source and binary forms, with or without |
5 | | // modification, are permitted provided that the following conditions are |
6 | | // met: |
7 | | // |
8 | | // * Redistributions of source code must retain the above copyright |
9 | | // notice, this list of conditions and the following disclaimer. |
10 | | // * Redistributions in binary form must reproduce the above |
11 | | // copyright notice, this list of conditions and the following disclaimer |
12 | | // in the documentation and/or other materials provided with the |
13 | | // distribution. |
14 | | // * Neither the name of Google Inc. nor the names of its |
15 | | // contributors may be used to endorse or promote products derived from |
16 | | // this software without specific prior written permission. |
17 | | // |
18 | | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
19 | | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
20 | | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
21 | | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
22 | | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
23 | | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
24 | | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
25 | | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
26 | | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
27 | | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
28 | | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
29 | | |
30 | | |
31 | | // Google Mock - a framework for writing C++ mock classes. |
32 | | // |
33 | | // This file implements cardinalities. |
34 | | |
35 | | #include "gmock/gmock-cardinalities.h" |
36 | | |
37 | | #include <limits.h> |
38 | | #include <ostream> // NOLINT |
39 | | #include <sstream> |
40 | | #include <string> |
41 | | #include "gmock/internal/gmock-internal-utils.h" |
42 | | #include "gtest/gtest.h" |
43 | | |
44 | | namespace testing { |
45 | | |
46 | | namespace { |
47 | | |
48 | | // Implements the Between(m, n) cardinality. |
49 | | class BetweenCardinalityImpl : public CardinalityInterface { |
50 | | public: |
51 | | BetweenCardinalityImpl(int min, int max) |
52 | | : min_(min >= 0 ? min : 0), |
53 | 1.68M | max_(max >= min_ ? max : min_) { |
54 | 1.68M | std::stringstream ss; |
55 | 1.68M | if (min < 0) { |
56 | 0 | ss << "The invocation lower bound must be >= 0, " |
57 | 0 | << "but is actually " << min << "."; |
58 | 0 | internal::Expect(false, __FILE__, __LINE__, ss.str()); |
59 | 1.68M | } else if (max < 0) { |
60 | 0 | ss << "The invocation upper bound must be >= 0, " |
61 | 0 | << "but is actually " << max << "."; |
62 | 0 | internal::Expect(false, __FILE__, __LINE__, ss.str()); |
63 | 1.68M | } else if (min > max) { |
64 | 0 | ss << "The invocation upper bound (" << max |
65 | 0 | << ") must be >= the invocation lower bound (" << min |
66 | 0 | << ")."; |
67 | 0 | internal::Expect(false, __FILE__, __LINE__, ss.str()); |
68 | 0 | } |
69 | 1.68M | } |
70 | | |
71 | | // Conservative estimate on the lower/upper bound of the number of |
72 | | // calls allowed. |
73 | 12.0k | int ConservativeLowerBound() const override { return min_; } |
74 | 12.0k | int ConservativeUpperBound() const override { return max_; } |
75 | | |
76 | 2.99M | bool IsSatisfiedByCallCount(int call_count) const override { |
77 | 2.99M | return min_ <= call_count && call_count <= max_; |
78 | 2.99M | } |
79 | | |
80 | 7.23M | bool IsSaturatedByCallCount(int call_count) const override { |
81 | 7.23M | return call_count >= max_; |
82 | 7.23M | } |
83 | | |
84 | | void DescribeTo(::std::ostream* os) const override; |
85 | | |
86 | | private: |
87 | | const int min_; |
88 | | const int max_; |
89 | | |
90 | | GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl); |
91 | | }; |
92 | | |
93 | | // Formats "n times" in a human-friendly way. |
94 | 297 | inline std::string FormatTimes(int n) { |
95 | 297 | if (n == 1) { |
96 | 297 | return "once"; |
97 | 297 | } else if (n == 2) { |
98 | 0 | return "twice"; |
99 | 0 | } else { |
100 | 0 | std::stringstream ss; |
101 | 0 | ss << n << " times"; |
102 | 0 | return ss.str(); |
103 | 0 | } |
104 | 297 | } |
105 | | |
106 | | // Describes the Between(m, n) cardinality in human-friendly text. |
107 | 1.35M | void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const { |
108 | 1.35M | if (min_ == 0) { |
109 | 1.35M | if (max_ == 0) { |
110 | 0 | *os << "never called"; |
111 | 1.35M | } else if (max_ == INT_MAX) { |
112 | 1.35M | *os << "called any number of times"; |
113 | 1.35M | } else { |
114 | 0 | *os << "called at most " << FormatTimes(max_); |
115 | 0 | } |
116 | 1.35M | } else if (min_ == max_) { |
117 | 43 | *os << "called " << FormatTimes(min_); |
118 | 243 | } else if (max_ == INT_MAX) { |
119 | 243 | *os << "called at least " << FormatTimes(min_); |
120 | 243 | } else { |
121 | | // 0 < min_ < max_ < INT_MAX |
122 | 0 | *os << "called between " << min_ << " and " << max_ << " times"; |
123 | 0 | } |
124 | 1.35M | } |
125 | | |
126 | | } // Unnamed namespace |
127 | | |
128 | | // Describes the given call count to an ostream. |
129 | | void Cardinality::DescribeActualCallCountTo(int actual_call_count, |
130 | 1.35M | ::std::ostream* os) { |
131 | 1.35M | if (actual_call_count > 0) { |
132 | 11 | *os << "called " << FormatTimes(actual_call_count); |
133 | 1.35M | } else { |
134 | 1.35M | *os << "never called"; |
135 | 1.35M | } |
136 | 1.35M | } |
137 | | |
138 | | // Creates a cardinality that allows at least n calls. |
139 | 219k | GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); } |
140 | | |
141 | | // Creates a cardinality that allows at most n calls. |
142 | 0 | GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); } |
143 | | |
144 | | // Creates a cardinality that allows any number of calls. |
145 | 6.49k | GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); } |
146 | | |
147 | | // Creates a cardinality that allows between min and max calls. |
148 | 1.68M | GTEST_API_ Cardinality Between(int min, int max) { |
149 | 1.68M | return Cardinality(new BetweenCardinalityImpl(min, max)); |
150 | 1.68M | } |
151 | | |
152 | | // Creates a cardinality that allows exactly n calls. |
153 | 1.46M | GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); } |
154 | | |
155 | | } // namespace testing |