1 /* 2 * Copyright (c) 2007 Mockito contributors 3 * This program is made available under the terms of the MIT License. 4 */ 5 6 package org.mockito; 7 8 import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress; 9 10 import org.mockito.internal.matchers.ArrayEquals; 11 import org.mockito.internal.matchers.CompareEqual; 12 import org.mockito.internal.matchers.EqualsWithDelta; 13 import org.mockito.internal.matchers.Find; 14 import org.mockito.internal.matchers.GreaterOrEqual; 15 import org.mockito.internal.matchers.GreaterThan; 16 import org.mockito.internal.matchers.LessOrEqual; 17 import 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") 42 public 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 */ geq(T value)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 */ geq(byte value)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 */ geq(double value)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 */ geq(float value)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 */ geq(int value)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 */ geq(long value)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 */ geq(short value)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 */ leq(T value)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 */ leq(byte value)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 */ leq(double value)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 */ leq(float value)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 */ leq(int value)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 */ leq(long value)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 */ leq(short value)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 */ gt(T value)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 */ gt(byte value)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 */ gt(double value)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 */ gt(float value)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 */ gt(int value)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 */ gt(long value)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 */ gt(short value)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 */ lt(T value)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 */ lt(byte value)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 */ lt(double value)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 */ lt(float value)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 */ lt(int value)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 */ lt(long value)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 */ lt(short value)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 */ cmpEq(T value)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 */ find(String regex)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 */ aryEq(T[] value)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 */ aryEq(short[] value)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 */ aryEq(long[] value)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 */ aryEq(int[] value)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 */ aryEq(float[] value)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 */ aryEq(double[] value)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 */ aryEq(char[] value)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 */ aryEq(byte[] value)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 */ aryEq(boolean[] value)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 */ and(boolean first, boolean second)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 */ and(byte first, byte second)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 */ and(char first, char second)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 */ and(double first, double second)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 */ and(float first, float second)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 */ and(int first, int second)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 */ and(long first, long second)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 */ and(short first, short second)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 */ and(T first, T second)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 */ or(boolean first, boolean second)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 */ or(T first, T second)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 */ or(short first, short second)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 */ or(long first, long second)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 */ or(int first, int second)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 */ or(float first, float second)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 */ or(double first, double second)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 */ or(char first, char second)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 */ or(byte first, byte second)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 */ not(T first)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 */ not(short first)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 */ not(int first)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 */ not(long first)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 */ not(float first)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 */ not(double first)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 */ not(char first)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 */ not(boolean first)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 */ not(byte first)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 */ eq(double value, double delta)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 */ eq(float value, float delta)1050 public static float eq(float value, float delta) { 1051 reportMatcher(new EqualsWithDelta(value, delta)); 1052 return 0; 1053 } 1054 reportMatcher(ArgumentMatcher<?> matcher)1055 private static void reportMatcher(ArgumentMatcher<?> matcher) { 1056 mockingProgress().getArgumentMatcherStorage().reportMatcher(matcher); 1057 } 1058 } 1059