1/*
2 * Copyright (c) 2007 Mockito contributors
3 * This program is made available under the terms of the MIT License.
4 */
5
6package org.mockito;
7
8import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
9
10import org.mockito.internal.matchers.ArrayEquals;
11import org.mockito.internal.matchers.CompareEqual;
12import org.mockito.internal.matchers.EqualsWithDelta;
13import org.mockito.internal.matchers.Find;
14import org.mockito.internal.matchers.GreaterOrEqual;
15import org.mockito.internal.matchers.GreaterThan;
16import org.mockito.internal.matchers.LessOrEqual;
17import org.mockito.internal.matchers.LessThan;
18
19/**
20 * See {@link Matchers} for general info about matchers.
21 * <p>
22 * AdditionalMatchers provides rarely used matchers, kept only for somewhat compatibility with EasyMock.
23 * Use additional matchers very judiciously because they may impact readability of a test.
24 * It is recommended to use matchers from {@link Matchers} and keep stubbing and verification simple.
25 * <p>
26 * Example of using logical and(), not(), or() matchers:
27 *
28 * <pre class="code"><code class="java">
29 *   //anything but not "ejb"
30 *   mock.someMethod(not(eq("ejb")));
31 *
32 *   //not "ejb" and not "michael jackson"
33 *   mock.someMethod(and(not(eq("ejb")), not(eq("michael jackson"))));
34 *
35 *   //1 or 10
36 *   mock.someMethod(or(eq(1), eq(10)));
37 * </code></pre>
38 *
39 * Scroll down to see all methods - full list of matchers.
40 */
41@SuppressWarnings("ALL")
42public class AdditionalMatchers {
43
44    /**
45     * argument greater than or equal the given value.
46     * <p>
47     * See examples in javadoc for {@link AdditionalMatchers} class
48     *
49     * @param value
50     *            the given value.
51     * @return <code>null</code>.
52     */
53    public static <T extends Comparable<T>> T geq(T value) {
54        reportMatcher(new GreaterOrEqual<T>(value));
55        return null;
56    }
57
58    /**
59     * byte argument greater than or equal to the given value.
60     * <p>
61     * See examples in javadoc for {@link AdditionalMatchers} class
62     *
63     * @param value
64     *            the given value.
65     * @return <code>0</code>.
66     */
67    public static byte geq(byte value) {
68        reportMatcher(new GreaterOrEqual<Byte>(value));
69        return 0;
70    }
71
72    /**
73     * double argument greater than or equal to the given value.
74     * <p>
75     * See examples in javadoc for {@link AdditionalMatchers} class
76     *
77     * @param value
78     *            the given value.
79     * @return <code>0</code>.
80     */
81    public static double geq(double value) {
82        reportMatcher(new GreaterOrEqual<Double>(value));
83        return 0;
84    }
85
86    /**
87     * float argument greater than or equal to the given value.
88     * <p>
89     * See examples in javadoc for {@link AdditionalMatchers} class
90     *
91     * @param value
92     *            the given value.
93     * @return <code>0</code>.
94     */
95    public static float geq(float value) {
96        reportMatcher(new GreaterOrEqual<Float>(value));
97        return 0;
98    }
99
100    /**
101     * int argument greater than or equal to the given value.
102     * <p>
103     * See examples in javadoc for {@link AdditionalMatchers} class
104     *
105     * @param value
106     *            the given value.
107     * @return <code>0</code>.
108     */
109    public static int geq(int value) {
110        reportMatcher(new GreaterOrEqual<Integer>(value));
111        return 0;
112    }
113
114    /**
115     * long argument greater than or equal to the given value.
116     * <p>
117     * See examples in javadoc for {@link AdditionalMatchers} class
118     *
119     * @param value
120     *            the given value.
121     * @return <code>0</code>.
122     */
123    public static long geq(long value) {
124        reportMatcher(new GreaterOrEqual<Long>(value));
125        return 0;
126    }
127
128    /**
129     * short argument greater than or equal to the given value.
130     * <p>
131     * See examples in javadoc for {@link AdditionalMatchers} class
132     *
133     * @param value
134     *            the given value.
135     * @return <code>0</code>.
136     */
137    public static short geq(short value) {
138        reportMatcher(new GreaterOrEqual<Short>(value));
139        return 0;
140    }
141
142    /**
143     * comparable argument less than or equal the given value details.
144     * <p>
145     * See examples in javadoc for {@link AdditionalMatchers} class
146     *
147     * @param value
148     *            the given value.
149     * @return <code>null</code>.
150     */
151    public static <T extends Comparable<T>> T leq(T value) {
152        reportMatcher(new LessOrEqual<T>(value));
153        return null;
154    }
155
156    /**
157     * byte argument less than or equal to the given value.
158     * <p>
159     * See examples in javadoc for {@link AdditionalMatchers} class
160     *
161     * @param value
162     *            the given value.
163     * @return <code>0</code>.
164     */
165    public static byte leq(byte value) {
166        reportMatcher(new LessOrEqual<Byte>(value));
167        return 0;
168    }
169
170    /**
171     * double argument less than or equal to the given value.
172     * <p>
173     * See examples in javadoc for {@link AdditionalMatchers} class
174     *
175     * @param value
176     *            the given value.
177     * @return <code>0</code>.
178     */
179    public static double leq(double value) {
180        reportMatcher(new LessOrEqual<Double>(value));
181        return 0;
182    }
183
184    /**
185     * float argument less than or equal to the given value.
186     * <p>
187     * See examples in javadoc for {@link AdditionalMatchers} class
188     *
189     * @param value
190     *            the given value.
191     * @return <code>0</code>.
192     */
193    public static float leq(float value) {
194        reportMatcher(new LessOrEqual<Float>(value));
195        return 0;
196    }
197
198    /**
199     * int argument less than or equal to the given value.
200     * <p>
201     * See examples in javadoc for {@link AdditionalMatchers} class
202     *
203     * @param value
204     *            the given value.
205     * @return <code>0</code>.
206     */
207    public static int leq(int value) {
208        reportMatcher(new LessOrEqual<Integer>(value));
209        return 0;
210    }
211
212    /**
213     * long argument less than or equal to the given value.
214     * <p>
215     * See examples in javadoc for {@link AdditionalMatchers} class
216     *
217     * @param value
218     *            the given value.
219     * @return <code>0</code>.
220     */
221    public static long leq(long value) {
222        reportMatcher(new LessOrEqual<Long>(value));
223        return 0;
224    }
225
226    /**
227     * short argument less than or equal to the given value.
228     * <p>
229     * See examples in javadoc for {@link AdditionalMatchers} class
230     *
231     * @param value
232     *            the given value.
233     * @return <code>0</code>.
234     */
235    public static short leq(short value) {
236        reportMatcher(new LessOrEqual<Short>(value));
237        return 0;
238    }
239
240    /**
241     * comparable argument greater than the given value.
242     * <p>
243     * See examples in javadoc for {@link AdditionalMatchers} class
244     *
245     * @param value
246     *            the given value.
247     * @return <code>null</code>.
248     */
249    public static <T extends Comparable<T>> T gt(T value) {
250        reportMatcher(new GreaterThan<T>(value));
251        return null;
252    }
253
254    /**
255     * byte argument greater than the given value.
256     * <p>
257     * See examples in javadoc for {@link AdditionalMatchers} class
258     *
259     * @param value
260     *            the given value.
261     * @return <code>0</code>.
262     */
263    public static byte gt(byte value) {
264        reportMatcher(new GreaterThan<Byte>(value));
265        return 0;
266    }
267
268    /**
269     * double argument greater than the given value.
270     * <p>
271     * See examples in javadoc for {@link AdditionalMatchers} class
272     *
273     * @param value
274     *            the given value.
275     * @return <code>0</code>.
276     */
277    public static double gt(double value) {
278        reportMatcher(new GreaterThan<Double>(value));
279        return 0;
280    }
281
282    /**
283     * float argument greater than the given value.
284     * <p>
285     * See examples in javadoc for {@link AdditionalMatchers} class
286     *
287     * @param value
288     *            the given value.
289     * @return <code>0</code>.
290     */
291    public static float gt(float value) {
292        reportMatcher(new GreaterThan<Float>(value));
293        return 0;
294    }
295
296    /**
297     * int argument greater than the given value.
298     * <p>
299     * See examples in javadoc for {@link AdditionalMatchers} class
300     *
301     * @param value
302     *            the given value.
303     * @return <code>0</code>.
304     */
305    public static int gt(int value) {
306        reportMatcher(new GreaterThan<Integer>(value));
307        return 0;
308    }
309
310    /**
311     * long argument greater than the given value.
312     * <p>
313     * See examples in javadoc for {@link AdditionalMatchers} class
314     *
315     * @param value
316     *            the given value.
317     * @return <code>0</code>.
318     */
319    public static long gt(long value) {
320        reportMatcher(new GreaterThan<Long>(value));
321        return 0;
322    }
323
324    /**
325     * short argument greater than the given value.
326     * <p>
327     * See examples in javadoc for {@link AdditionalMatchers} class
328     *
329     * @param value
330     *            the given value.
331     * @return <code>0</code>.
332     */
333    public static short gt(short value) {
334        reportMatcher(new GreaterThan<Short>(value));
335        return 0;
336    }
337
338    /**
339     * comparable argument less than the given value.
340     * <p>
341     * See examples in javadoc for {@link AdditionalMatchers} class
342     *
343     * @param value
344     *            the given value.
345     * @return <code>null</code>.
346     */
347    public static <T extends Comparable<T>> T lt(T value) {
348        reportMatcher(new LessThan<T>(value));
349        return null;
350    }
351
352    /**
353     * byte argument less than the given value.
354     * <p>
355     * See examples in javadoc for {@link AdditionalMatchers} class
356     *
357     * @param value
358     *            the given value.
359     * @return <code>0</code>.
360     */
361    public static byte lt(byte value) {
362        reportMatcher(new LessThan<Byte>(value));
363        return 0;
364    }
365
366    /**
367     * double argument less than the given value.
368     * <p>
369     * See examples in javadoc for {@link AdditionalMatchers} class
370     *
371     * @param value
372     *            the given value.
373     * @return <code>0</code>.
374     */
375    public static double lt(double value) {
376        reportMatcher(new LessThan<Double>(value));
377        return 0;
378    }
379
380    /**
381     * float argument less than the given value.
382     * <p>
383     * See examples in javadoc for {@link AdditionalMatchers} class
384     *
385     * @param value
386     *            the given value.
387     * @return <code>0</code>.
388     */
389    public static float lt(float value) {
390        reportMatcher(new LessThan<Float>(value));
391        return 0;
392    }
393
394    /**
395     * int argument less than the given value.
396     * <p>
397     * See examples in javadoc for {@link AdditionalMatchers} class
398     *
399     * @param value
400     *            the given value.
401     * @return <code>0</code>.
402     */
403    public static int lt(int value) {
404        reportMatcher(new LessThan<Integer>(value));
405        return 0;
406    }
407
408    /**
409     * long argument less than the given value.
410     * <p>
411     * See examples in javadoc for {@link AdditionalMatchers} class
412     *
413     * @param value
414     *            the given value.
415     * @return <code>0</code>.
416     */
417    public static long lt(long value) {
418        reportMatcher(new LessThan<Long>(value));
419        return 0;
420    }
421
422    /**
423     * short argument less than the given value.
424     * <p>
425     * See examples in javadoc for {@link AdditionalMatchers} class
426     *
427     * @param value
428     *            the given value.
429     * @return <code>0</code>.
430     */
431    public static short lt(short value) {
432        reportMatcher(new LessThan<Short>(value));
433        return 0;
434    }
435
436    /**
437     * comparable argument equals to the given value according to their
438     * compareTo method.
439     * <p>
440     * See examples in javadoc for {@link AdditionalMatchers} class
441     *
442     * @param value
443     *            the given value.
444     * @return <code>null</code>.
445     */
446    public static <T extends Comparable<T>> T cmpEq(T value) {
447        reportMatcher(new CompareEqual<T>(value));
448        return null;
449    }
450
451    /**
452     * String argument that contains a substring that matches the given regular
453     * expression.
454     *
455     * @param regex
456     *            the regular expression.
457     * @return <code>null</code>.
458     */
459    public static String find(String regex) {
460        reportMatcher(new Find(regex));
461        return null;
462    }
463
464    /**
465     * Object array argument that is equal to the given array, i.e. it has to
466     * have the same type, length, and each element has to be equal.
467     * <p>
468     * See examples in javadoc for {@link AdditionalMatchers} class
469     *
470     * @param <T>
471     *            the type of the array, it is passed through to prevent casts.
472     * @param value
473     *            the given array.
474     * @return <code>null</code>.
475     */
476    public static <T> T[] aryEq(T[] value) {
477        reportMatcher(new ArrayEquals(value));
478        return null;
479    }
480
481    /**
482     * short array argument that is equal to the given array, i.e. it has to
483     * have the same length, and each element has to be equal.
484     * <p>
485     * See examples in javadoc for {@link AdditionalMatchers} class
486     *
487     * @param value
488     *            the given array.
489     * @return <code>null</code>.
490     */
491    public static short[] aryEq(short[] value) {
492        reportMatcher(new ArrayEquals(value));
493        return null;
494    }
495
496    /**
497     * long array argument that is equal to the given array, i.e. it has to have
498     * the same length, and each element has to be equal.
499     * <p>
500     * See examples in javadoc for {@link AdditionalMatchers} class
501     *
502     * @param value
503     *            the given array.
504     * @return <code>null</code>.
505     */
506    public static long[] aryEq(long[] value) {
507        reportMatcher(new ArrayEquals(value));
508        return null;
509    }
510
511    /**
512     * int array argument that is equal to the given array, i.e. it has to have
513     * the same length, and each element has to be equal.
514     * <p>
515     * See examples in javadoc for {@link AdditionalMatchers} class
516     *
517     * @param value
518     *            the given array.
519     * @return <code>null</code>.
520     */
521    public static int[] aryEq(int[] value) {
522        reportMatcher(new ArrayEquals(value));
523        return null;
524    }
525
526    /**
527     * float array argument that is equal to the given array, i.e. it has to
528     * have the same length, and each element has to be equal.
529     * <p>
530     * See examples in javadoc for {@link AdditionalMatchers} class
531     *
532     * @param value
533     *            the given array.
534     * @return <code>null</code>.
535     */
536    public static float[] aryEq(float[] value) {
537        reportMatcher(new ArrayEquals(value));
538        return null;
539    }
540
541    /**
542     * double array argument that is equal to the given array, i.e. it has to
543     * have the same length, and each element has to be equal.
544     * <p>
545     * See examples in javadoc for {@link AdditionalMatchers} class
546     *
547     * @param value
548     *            the given array.
549     * @return <code>null</code>.
550     */
551    public static double[] aryEq(double[] value) {
552        reportMatcher(new ArrayEquals(value));
553        return null;
554    }
555
556    /**
557     * char array argument that is equal to the given array, i.e. it has to have
558     * the same length, and each element has to be equal.
559     * <p>
560     * See examples in javadoc for {@link AdditionalMatchers} class
561     *
562     * @param value
563     *            the given array.
564     * @return <code>null</code>.
565     */
566    public static char[] aryEq(char[] value) {
567        reportMatcher(new ArrayEquals(value));
568        return null;
569    }
570
571    /**
572     * byte array argument that is equal to the given array, i.e. it has to have
573     * the same length, and each element has to be equal.
574     * <p>
575     * See examples in javadoc for {@link AdditionalMatchers} class
576     *
577     * @param value
578     *            the given array.
579     * @return <code>null</code>.
580     */
581    public static byte[] aryEq(byte[] value) {
582        reportMatcher(new ArrayEquals(value));
583        return null;
584    }
585
586    /**
587     * boolean array argument that is equal to the given array, i.e. it has to
588     * have the same length, and each element has to be equal.
589     * <p>
590     * See examples in javadoc for {@link AdditionalMatchers} class
591     *
592     * @param value
593     *            the given array.
594     * @return <code>null</code>.
595     */
596    public static boolean[] aryEq(boolean[] value) {
597        reportMatcher(new ArrayEquals(value));
598        return null;
599    }
600
601    /**
602     * boolean argument that matches both given matchers.
603     * <p>
604     * See examples in javadoc for {@link AdditionalMatchers} class
605     *
606     * @param first
607     *            placeholder for the first argument matcher.
608     * @param second
609     *            placeholder for the second argument matcher.
610     * @return <code>false</code>.
611     */
612    public static boolean and(boolean first, boolean second) {
613        mockingProgress().getArgumentMatcherStorage().reportAnd();
614        return false;
615    }
616
617    /**
618     * byte argument that matches both given argument matchers.
619     * <p>
620     * See examples in javadoc for {@link AdditionalMatchers} class
621     *
622     * @param first
623     *            placeholder for the first argument matcher.
624     * @param second
625     *            placeholder for the second argument matcher.
626     * @return <code>0</code>.
627     */
628    public static byte and(byte first, byte second) {
629        mockingProgress().getArgumentMatcherStorage().reportAnd();
630        return 0;
631    }
632
633    /**
634     * char argument that matches both given argument matchers.
635     * <p>
636     * See examples in javadoc for {@link AdditionalMatchers} class
637     *
638     * @param first
639     *            placeholder for the first argument matcher.
640     * @param second
641     *            placeholder for the second argument matcher.
642     * @return <code>0</code>.
643     */
644    public static char and(char first, char second) {
645        mockingProgress().getArgumentMatcherStorage().reportAnd();
646        return 0;
647    }
648
649    /**
650     * double argument that matches both given argument matchers.
651     * <p>
652     * See examples in javadoc for {@link AdditionalMatchers} class
653     *
654     * @param first
655     *            placeholder for the first argument matcher.
656     * @param second
657     *            placeholder for the second argument matcher.
658     * @return <code>0</code>.
659     */
660    public static double and(double first, double second) {
661        mockingProgress().getArgumentMatcherStorage().reportAnd();
662        return 0;
663    }
664
665    /**
666     * float argument that matches both given argument matchers.
667     * <p>
668     * See examples in javadoc for {@link AdditionalMatchers} class
669     *
670     * @param first
671     *            placeholder for the first argument matcher.
672     * @param second
673     *            placeholder for the second argument matcher.
674     * @return <code>0</code>.
675     */
676    public static float and(float first, float second) {
677        mockingProgress().getArgumentMatcherStorage().reportAnd();
678        return 0;
679    }
680
681    /**
682     * int argument that matches both given argument matchers.
683     * <p>
684     * See examples in javadoc for {@link AdditionalMatchers} class
685     *
686     * @param first
687     *            placeholder for the first argument matcher.
688     * @param second
689     *            placeholder for the second argument matcher.
690     * @return <code>0</code>.
691     */
692    public static int and(int first, int second) {
693        mockingProgress().getArgumentMatcherStorage().reportAnd();
694        return 0;
695    }
696
697    /**
698     * long argument that matches both given argument matchers.
699     * <p>
700     * See examples in javadoc for {@link AdditionalMatchers} class
701     *
702     * @param first
703     *            placeholder for the first argument matcher.
704     * @param second
705     *            placeholder for the second argument matcher.
706     * @return <code>0</code>.
707     */
708    public static long and(long first, long second) {
709        mockingProgress().getArgumentMatcherStorage().reportAnd();
710        return 0;
711    }
712
713    /**
714     * short argument that matches both given argument matchers.
715     * <p>
716     * See examples in javadoc for {@link AdditionalMatchers} class
717     *
718     * @param first
719     *            placeholder for the first argument matcher.
720     * @param second
721     *            placeholder for the second argument matcher.
722     * @return <code>0</code>.
723     */
724    public static short and(short first, short second) {
725        mockingProgress().getArgumentMatcherStorage().reportAnd();
726        return 0;
727    }
728
729    /**
730     * Object argument that matches both given argument matchers.
731     * <p>
732     * See examples in javadoc for {@link AdditionalMatchers} class
733     *
734     * @param <T>
735     *            the type of the object, it is passed through to prevent casts.
736     * @param first
737     *            placeholder for the first argument matcher.
738     * @param second
739     *            placeholder for the second argument matcher.
740     * @return <code>null</code>.
741     */
742    public static <T> T and(T first, T second) {
743        mockingProgress().getArgumentMatcherStorage().reportAnd();
744        return null;
745    }
746
747    /**
748     * boolean argument that matches any of the given argument matchers.
749     * <p>
750     * See examples in javadoc for {@link AdditionalMatchers} class
751     *
752     * @param first
753     *            placeholder for the first argument matcher.
754     * @param second
755     *            placeholder for the second argument matcher.
756     * @return <code>false</code>.
757     */
758    public static boolean or(boolean first, boolean second) {
759        mockingProgress().getArgumentMatcherStorage().reportOr();
760        return false;
761    }
762
763    /**
764     * Object argument that matches any of the given argument matchers.
765     * <p>
766     * See examples in javadoc for {@link AdditionalMatchers} class
767     *
768     * @param <T>
769     *            the type of the object, it is passed through to prevent casts.
770     * @param first
771     *            placeholder for the first argument matcher.
772     * @param second
773     *            placeholder for the second argument matcher.
774     * @return <code>null</code>.
775     */
776    public static <T> T or(T first, T second) {
777        mockingProgress().getArgumentMatcherStorage().reportOr();
778        return null;
779    }
780
781    /**
782     * short argument that matches any of the given argument matchers.
783     * <p>
784     * See examples in javadoc for {@link AdditionalMatchers} class
785     *
786     * @param first
787     *            placeholder for the first argument matcher.
788     * @param second
789     *            placeholder for the second argument matcher.
790     * @return <code>0</code>.
791     */
792    public static short or(short first, short second) {
793        mockingProgress().getArgumentMatcherStorage().reportOr();
794        return 0;
795    }
796
797    /**
798     * long argument that matches any of the given argument matchers.
799     * <p>
800     * See examples in javadoc for {@link AdditionalMatchers} class
801     *
802     * @param first
803     *            placeholder for the first argument matcher.
804     * @param second
805     *            placeholder for the second argument matcher.
806     * @return <code>0</code>.
807     */
808    public static long or(long first, long second) {
809        mockingProgress().getArgumentMatcherStorage().reportOr();
810        return 0;
811    }
812
813    /**
814     * int argument that matches any of the given argument matchers.
815     * <p>
816     * See examples in javadoc for {@link AdditionalMatchers} class
817     *
818     * @param first
819     *            placeholder for the first argument matcher.
820     * @param second
821     *            placeholder for the second argument matcher.
822     * @return <code>0</code>.
823     */
824    public static int or(int first, int second) {
825        mockingProgress().getArgumentMatcherStorage().reportOr();
826        return 0;
827    }
828
829    /**
830     * float argument that matches any of the given argument matchers.
831     * <p>
832     * See examples in javadoc for {@link AdditionalMatchers} class
833     *
834     * @param first
835     *            placeholder for the first argument matcher.
836     * @param second
837     *            placeholder for the second argument matcher.
838     * @return <code>0</code>.
839     */
840    public static float or(float first, float second) {
841        mockingProgress().getArgumentMatcherStorage().reportOr();
842        return 0;
843    }
844
845    /**
846     * double argument that matches any of the given argument matchers.
847     * <p>
848     * See examples in javadoc for {@link AdditionalMatchers} class
849     *
850     * @param first
851     *            placeholder for the first argument matcher.
852     * @param second
853     *            placeholder for the second argument matcher.
854     * @return <code>0</code>.
855     */
856    public static double or(double first, double second) {
857        mockingProgress().getArgumentMatcherStorage().reportOr();
858        return 0;
859    }
860
861    /**
862     * char argument that matches any of the given argument matchers.
863     * <p>
864     * See examples in javadoc for {@link AdditionalMatchers} class
865     *
866     * @param first
867     *            placeholder for the first argument matcher.
868     * @param second
869     *            placeholder for the second argument matcher.
870     * @return <code>0</code>.
871     */
872    public static char or(char first, char second) {
873        mockingProgress().getArgumentMatcherStorage().reportOr();
874        return 0;
875    }
876
877    /**
878     * byte argument that matches any of the given argument matchers.
879     * <p>
880     * See examples in javadoc for {@link AdditionalMatchers} class
881     *
882     * @param first
883     *            placeholder for the first argument matcher.
884     * @param second
885     *            placeholder for the second argument matcher.
886     * @return <code>0</code>.
887     */
888    public static byte or(byte first, byte second) {
889        mockingProgress().getArgumentMatcherStorage().reportOr();
890        return 0;
891    }
892
893    /**
894     * Object argument that does not match the given argument matcher.
895     * <p>
896     * See examples in javadoc for {@link AdditionalMatchers} class
897     *
898     * @param <T>
899     *            the type of the object, it is passed through to prevent casts.
900     * @param first
901     *            placeholder for the argument matcher.
902     * @return <code>null</code>.
903     */
904    public static <T> T not(T first) {
905        mockingProgress().getArgumentMatcherStorage().reportNot();
906        return null;
907    }
908
909    /**
910     * short argument that does not match the given argument matcher.
911     * <p>
912     * See examples in javadoc for {@link AdditionalMatchers} class
913     *
914     * @param first
915     *            placeholder for the argument matcher.
916     * @return <code>0</code>.
917     */
918    public static short not(short first) {
919        mockingProgress().getArgumentMatcherStorage().reportNot();
920        return 0;
921    }
922
923    /**
924     * int argument that does not match the given argument matcher.
925     * <p>
926     * See examples in javadoc for {@link AdditionalMatchers} class
927     *
928     * @param first
929     *            placeholder for the argument matcher.
930     * @return <code>0</code>.
931     */
932    public static int not(int first) {
933        mockingProgress().getArgumentMatcherStorage().reportNot();
934        return 0;
935    }
936
937    /**
938     * long argument that does not match the given argument matcher.
939     * <p>
940     * See examples in javadoc for {@link AdditionalMatchers} class
941     *
942     * @param first
943     *            placeholder for the argument matcher.
944     * @return <code>0</code>.
945     */
946    public static long not(long first) {
947        mockingProgress().getArgumentMatcherStorage().reportNot();
948        return 0;
949    }
950
951    /**
952     * float argument that does not match the given argument matcher.
953     * <p>
954     * See examples in javadoc for {@link AdditionalMatchers} class
955     *
956     * @param first
957     *            placeholder for the argument matcher.
958     * @return <code>0</code>.
959     */
960    public static float not(float first) {
961        mockingProgress().getArgumentMatcherStorage().reportNot();
962        return 0;
963    }
964
965    /**
966     * double argument that does not match the given argument matcher.
967     * <p>
968     * See examples in javadoc for {@link AdditionalMatchers} class
969     *
970     * @param first
971     *            placeholder for the argument matcher.
972     * @return <code>0</code>.
973     */
974    public static double not(double first) {
975        mockingProgress().getArgumentMatcherStorage().reportNot();
976        return 0;
977    }
978
979    /**
980     * char argument that does not match the given argument matcher.
981     * <p>
982     * See examples in javadoc for {@link AdditionalMatchers} class
983     *
984     * @param first
985     *            placeholder for the argument matcher.
986     * @return <code>0</code>.
987     */
988    public static char not(char first) {
989        mockingProgress().getArgumentMatcherStorage().reportNot();
990        return 0;
991    }
992
993    /**
994     * boolean argument that does not match the given argument matcher.
995     * <p>
996     * See examples in javadoc for {@link AdditionalMatchers} class
997     *
998     * @param first
999     *            placeholder for the argument matcher.
1000     * @return <code>false</code>.
1001     */
1002    public static boolean not(boolean first) {
1003        mockingProgress().getArgumentMatcherStorage().reportNot();
1004        return false;
1005    }
1006
1007    /**
1008     * byte argument that does not match the given argument matcher.
1009     * <p>
1010     * See examples in javadoc for {@link AdditionalMatchers} class
1011     *
1012     * @param first
1013     *            placeholder for the argument matcher.
1014     * @return <code>0</code>.
1015     */
1016    public static byte not(byte first) {
1017        mockingProgress().getArgumentMatcherStorage().reportNot();
1018        return 0;
1019    }
1020
1021    /**
1022     * double argument that has an absolute difference to the given value that
1023     * is less than the given delta details.
1024     * <p>
1025     * See examples in javadoc for {@link AdditionalMatchers} class
1026     *
1027     * @param value
1028     *            the given value.
1029     * @param delta
1030     *            the given delta.
1031     * @return <code>0</code>.
1032     */
1033    public static double eq(double value, double delta) {
1034        reportMatcher(new EqualsWithDelta(value, delta));
1035        return 0;
1036    }
1037
1038    /**
1039     * float argument that has an absolute difference to the given value that is
1040     * less than the given delta details.
1041     * <p>
1042     * See examples in javadoc for {@link AdditionalMatchers} class
1043     *
1044     * @param value
1045     *            the given value.
1046     * @param delta
1047     *            the given delta.
1048     * @return <code>0</code>.
1049     */
1050    public static float eq(float value, float delta) {
1051        reportMatcher(new EqualsWithDelta(value, delta));
1052        return 0;
1053    }
1054
1055    private static void reportMatcher(ArgumentMatcher<?> matcher) {
1056        mockingProgress().getArgumentMatcherStorage().reportMatcher(matcher);
1057    }
1058}
1059