Debian Codegraph @

closure-library/closure/goog/labs/testing/numbermatcher.js

raw
1 // Copyright 2012 The Closure Library Authors. 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 /**
16 * @fileoverview Provides the built-in number matchers like lessThan,
17 * greaterThan, etc.
18 */
19
20 goog.provide('goog.labs.testing.AnyNumberMatcher');
21 goog.provide('goog.labs.testing.CloseToMatcher');
22 goog.provide('goog.labs.testing.EqualToMatcher');
23 goog.provide('goog.labs.testing.GreaterThanEqualToMatcher');
24 goog.provide('goog.labs.testing.GreaterThanMatcher');
25 goog.provide('goog.labs.testing.LessThanEqualToMatcher');
26 goog.provide('goog.labs.testing.LessThanMatcher');
27
28 goog.require('goog.asserts');
29 goog.require('goog.labs.testing.Matcher');
30
31
32
33 /**
34 * Matches any number value.
35 *
36 * @constructor @struct @implements {goog.labs.testing.Matcher} @final
37 */
38 goog.labs.testing.AnyNumberMatcher = function() {};
39
40
41 /** @override */
42 goog.labs.testing.AnyNumberMatcher.prototype.matches = function(actualValue) {
43 return goog.isNumber(actualValue);
44 };
45
46
47 /** @override */
48 goog.labs.testing.AnyNumberMatcher.prototype.describe = function(actualValue) {
49 return '<' + actualValue + '> is not a number';
50 };
51
52
53
54 /**
55 * The GreaterThan matcher.
56 *
57 * @param {number} value The value to compare.
58 *
59 * @constructor
60 * @struct
61 * @implements {goog.labs.testing.Matcher}
62 * @final
63 */
64 goog.labs.testing.GreaterThanMatcher = function(value) {
65 /**
66 * @type {number}
67 * @private
68 */
69 this.value_ = value;
70 };
71
72
73 /**
74 * Determines if input value is greater than the expected value.
75 *
76 * @override
77 */
78 goog.labs.testing.GreaterThanMatcher.prototype.matches = function(actualValue) {
79 goog.asserts.assertNumber(actualValue);
80 return actualValue > this.value_;
81 };
82
83
84 /**
85 * @override
86 */
87 goog.labs.testing.GreaterThanMatcher.prototype.describe = function(
88 actualValue) {
89 goog.asserts.assertNumber(actualValue);
90 return actualValue + ' is not greater than ' + this.value_;
91 };
92
93
94
95 /**
96 * The lessThan matcher.
97 *
98 * @param {number} value The value to compare.
99 *
100 * @constructor
101 * @struct
102 * @implements {goog.labs.testing.Matcher}
103 * @final
104 */
105 goog.labs.testing.LessThanMatcher = function(value) {
106 /**
107 * @type {number}
108 * @private
109 */
110 this.value_ = value;
111 };
112
113
114 /**
115 * Determines if the input value is less than the expected value.
116 *
117 * @override
118 */
119 goog.labs.testing.LessThanMatcher.prototype.matches = function(actualValue) {
120 goog.asserts.assertNumber(actualValue);
121 return actualValue < this.value_;
122 };
123
124
125 /**
126 * @override
127 */
128 goog.labs.testing.LessThanMatcher.prototype.describe = function(actualValue) {
129 goog.asserts.assertNumber(actualValue);
130 return actualValue + ' is not less than ' + this.value_;
131 };
132
133
134
135 /**
136 * The GreaterThanEqualTo matcher.
137 *
138 * @param {number} value The value to compare.
139 *
140 * @constructor
141 * @struct
142 * @implements {goog.labs.testing.Matcher}
143 * @final
144 */
145 goog.labs.testing.GreaterThanEqualToMatcher = function(value) {
146 /**
147 * @type {number}
148 * @private
149 */
150 this.value_ = value;
151 };
152
153
154 /**
155 * Determines if the input value is greater than equal to the expected value.
156 *
157 * @override
158 */
159 goog.labs.testing.GreaterThanEqualToMatcher.prototype.matches = function(
160 actualValue) {
161 goog.asserts.assertNumber(actualValue);
162 return actualValue >= this.value_;
163 };
164
165
166 /**
167 * @override
168 */
169 goog.labs.testing.GreaterThanEqualToMatcher.prototype.describe = function(
170 actualValue) {
171 goog.asserts.assertNumber(actualValue);
172 return actualValue + ' is not greater than equal to ' + this.value_;
173 };
174
175
176
177 /**
178 * The LessThanEqualTo matcher.
179 *
180 * @param {number} value The value to compare.
181 *
182 * @constructor
183 * @struct
184 * @implements {goog.labs.testing.Matcher}
185 * @final
186 */
187 goog.labs.testing.LessThanEqualToMatcher = function(value) {
188 /**
189 * @type {number}
190 * @private
191 */
192 this.value_ = value;
193 };
194
195
196 /**
197 * Determines if the input value is less than or equal to the expected value.
198 *
199 * @override
200 */
201 goog.labs.testing.LessThanEqualToMatcher.prototype.matches = function(
202 actualValue) {
203 goog.asserts.assertNumber(actualValue);
204 return actualValue <= this.value_;
205 };
206
207
208 /**
209 * @override
210 */
211 goog.labs.testing.LessThanEqualToMatcher.prototype.describe = function(
212 actualValue) {
213 goog.asserts.assertNumber(actualValue);
214 return actualValue + ' is not less than equal to ' + this.value_;
215 };
216
217
218
219 /**
220 * The EqualTo matcher.
221 *
222 * @param {number} value The value to compare.
223 *
224 * @constructor
225 * @struct
226 * @implements {goog.labs.testing.Matcher}
227 * @final
228 */
229 goog.labs.testing.EqualToMatcher = function(value) {
230 /**
231 * @type {number}
232 * @private
233 */
234 this.value_ = value;
235 };
236
237
238 /**
239 * Determines if the input value is equal to the expected value.
240 *
241 * @override
242 */
243 goog.labs.testing.EqualToMatcher.prototype.matches = function(actualValue) {
244 goog.asserts.assertNumber(actualValue);
245 return actualValue === this.value_;
246 };
247
248
249 /**
250 * @override
251 */
252 goog.labs.testing.EqualToMatcher.prototype.describe = function(actualValue) {
253 goog.asserts.assertNumber(actualValue);
254 return actualValue + ' is not equal to ' + this.value_;
255 };
256
257
258
259 /**
260 * The CloseTo matcher.
261 *
262 * @param {number} value The value to compare.
263 * @param {number} range The range to check within.
264 *
265 * @constructor
266 * @struct
267 * @implements {goog.labs.testing.Matcher}
268 * @final
269 */
270 goog.labs.testing.CloseToMatcher = function(value, range) {
271 /**
272 * @type {number}
273 * @private
274 */
275 this.value_ = value;
276 /**
277 * @type {number}
278 * @private
279 */
280 this.range_ = range;
281 };
282
283
284 /**
285 * Determines if input value is within a certain range of the expected value.
286 *
287 * @override
288 */
289 goog.labs.testing.CloseToMatcher.prototype.matches = function(actualValue) {
290 goog.asserts.assertNumber(actualValue);
291 return Math.abs(this.value_ - actualValue) < this.range_;
292 };
293
294
295 /**
296 * @override
297 */
298 goog.labs.testing.CloseToMatcher.prototype.describe = function(actualValue) {
299 goog.asserts.assertNumber(actualValue);
300 return actualValue + ' is not close to(' + this.range_ + ') ' + this.value_;
301 };
302
303
304 /** @return {!goog.labs.testing.AnyNumberMatcher} */
305 function anyNumber() {
306 return new goog.labs.testing.AnyNumberMatcher();
307 }
308
309
310 /**
311 * @param {number} value The expected value.
312 *
313 * @return {!goog.labs.testing.GreaterThanMatcher} A GreaterThanMatcher.
314 */
315 function greaterThan(value) {
316 return new goog.labs.testing.GreaterThanMatcher(value);
317 }
318
319
320 /**
321 * @param {number} value The expected value.
322 *
323 * @return {!goog.labs.testing.GreaterThanEqualToMatcher} A
324 * GreaterThanEqualToMatcher.
325 */
326 function greaterThanEqualTo(value) {
327 return new goog.labs.testing.GreaterThanEqualToMatcher(value);
328 }
329
330
331 /**
332 * @param {number} value The expected value.
333 *
334 * @return {!goog.labs.testing.LessThanMatcher} A LessThanMatcher.
335 */
336 function lessThan(value) {
337 return new goog.labs.testing.LessThanMatcher(value);
338 }
339
340
341 /**
342 * @param {number} value The expected value.
343 *
344 * @return {!goog.labs.testing.LessThanEqualToMatcher} A LessThanEqualToMatcher.
345 */
346 function lessThanEqualTo(value) {
347 return new goog.labs.testing.LessThanEqualToMatcher(value);
348 }
349
350
351 /**
352 * @param {number} value The expected value.
353 *
354 * @return {!goog.labs.testing.EqualToMatcher} An EqualToMatcher.
355 */
356 function equalTo(value) {
357 return new goog.labs.testing.EqualToMatcher(value);
358 }
359
360
361 /**
362 * @param {number} value The expected value.
363 * @param {number} range The maximum allowed difference from the expected value.
364 *
365 * @return {!goog.labs.testing.CloseToMatcher} A CloseToMatcher.
366 */
367 function closeTo(value, range) {
368 return new goog.labs.testing.CloseToMatcher(value, range);
369 }