How to use anyChar method of org.easymock.EasyMock class

Best Easymock code snippet using org.easymock.EasyMock.anyChar

Source:AndroidMock.java

...306   * If this method is used for anything other than to set a parameter expectation as part of a307   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.308   * 309   * E.g.310   * {@code AndroidMock.expect(mock.getString(AndroidMock.anyChar())).andReturn("hello world");}311   * 312   * @return {@code 0}. The return value is always ignored.313   */314  public static char anyChar() {315    return EasyMock.anyChar();316  }317  /**318   * Expects any {@code int} argument as a parameter to a mocked method.319   * Use this to loosen the expectations of acceptable parameters for a mocked method call.320   * 321   * If this method is used for anything other than to set a parameter expectation as part of a322   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.323   * 324   * E.g.325   * {@code AndroidMock.expect(mock.getString(AndroidMock.anyInt())).andReturn("hello world");}326   * 327   * @return {@code 0}. The return value is always ignored.328   */329  public static int anyInt() {330    return EasyMock.anyInt();331  }332  /**333   * Expects any {@code long} argument as a parameter to a mocked method.334   * Use this to loosen the expectations of acceptable parameters for a mocked method call.335   * 336   * If this method is used for anything other than to set a parameter expectation as part of a337   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.338   * 339   * E.g.340   * {@code AndroidMock.expect(mock.getString(AndroidMock.anyLong())).andReturn("hello world");}341   * 342   * @return {@code 0}. The return value is always ignored.343   */344  public static long anyLong() {345    return EasyMock.anyLong();346  }347  /**348   * Expects any {@code float} argument as a parameter to a mocked method.349   * Use this to loosen the expectations of acceptable parameters for a mocked method call.350   * 351   * If this method is used for anything other than to set a parameter expectation as part of a352   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.353   * 354   * E.g.355   * {@code AndroidMock.expect(mock.getString(AndroidMock.anyFloat())).andReturn("hello world");}356   * 357   * @return {@code 0}. The return value is always ignored.358   */359  public static float anyFloat() {360    return EasyMock.anyFloat();361  }362  /**363   * Expects any {@code double} argument as a parameter to a mocked method.364   * Use this to loosen the expectations of acceptable parameters for a mocked method call.365   * 366   * If this method is used for anything other than to set a parameter expectation as part of a367   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.368   * 369   * E.g.370   * {@code AndroidMock.expect(mock.getString(AndroidMock.anyDouble())).andReturn("hello world");}371   * 372   * @return {@code 0}. The return value is always ignored.   */373  public static double anyDouble() {374    return EasyMock.anyDouble();375  }376  /**377   * Expects any {@code short} argument as a parameter to a mocked method.378   * Use this to loosen the expectations of acceptable parameters for a mocked method call.379   * 380   * If this method is used for anything other than to set a parameter expectation as part of a381   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.382   * 383   * E.g.384   * {@code AndroidMock.expect(mock.getString(AndroidMock.anyShort())).andReturn("hello world");}385   * 386   * @return {@code 0}. The return value is always ignored.   */387  public static short anyShort() {388    return EasyMock.anyShort();389  }390  /**391   * Expects any {@code java.lang.Object} (or subclass) argument as a parameter to a mocked method.392   * Note that this includes Arrays (since an array {@literal is an Object})393   * Use this to loosen the expectations of acceptable parameters for a mocked method call.394   * 395   * If this method is used for anything other than to set a parameter expectation as part of a396   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.397   * 398   * E.g.399   * {@code AndroidMock.expect(mock.getString(AndroidMock.anyLong())).andReturn("hello world");}400   * 401   * @return {@code 0}. The return value is always ignored.402   */403  @SuppressWarnings("unchecked")404  public static <T> T anyObject() {405    return (T) EasyMock.anyObject();406  }407  /**408   * Expects a {@code Comparable} argument greater than or equal to the given value as a parameter409   * to a mocked method.410   * 411   * Use this to loosen the expectations of acceptable parameters for a mocked method call.412   * 413   * If this method is used for anything other than to set a parameter expectation as part of a414   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.415   * 416   * E.g.417   * {@code AndroidMock.expect(mock.getString(AndroidMock.geq("hi"))).andReturn("hello");}418   * 419   * @param expectedValue the value to which the specified incoming parameter to the mocked method420   * must be greater than or equal.421   * @return {@code null}. The return value is always ignored.422   */423  public static <T extends Comparable<T>> T geq(Comparable<T> expectedValue) {424    return EasyMock.geq(expectedValue);425  }426  /**427   * Expects a {@code byte} argument greater than or equal to the given value as a parameter428   * to a mocked method.429   * 430   * Use this to loosen the expectations of acceptable parameters for a mocked method call.431   * 432   * If this method is used for anything other than to set a parameter expectation as part of a433   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.434   * 435   * E.g.436   * {@code AndroidMock.expect(mock.getString(AndroidMock.geq((byte)42))).andReturn("hello");}437   * 438   * @param expectedValue the value to which the specified incoming parameter to the mocked method439   * must be greater than or equal.440   * @return {@code 0}. The return value is always ignored.441   */442  public static byte geq(byte expectedValue) {443    return EasyMock.geq(expectedValue);444  }445  /**446   * Expects a {@code double} argument greater than or equal to the given value as a parameter447   * to a mocked method.448   * 449   * Use this to loosen the expectations of acceptable parameters for a mocked method call.450   * 451   * If this method is used for anything other than to set a parameter expectation as part of a452   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.453   * 454   * E.g.455   * {@code AndroidMock.expect(mock.getString(AndroidMock.geq(42.0))).andReturn("hello");}456   * 457   * @param expectedValue the value to which the specified incoming parameter to the mocked method458   * must be greater than or equal.459   * @return {@code 0}. The return value is always ignored.460   */461  public static double geq(double expectedValue) {462    return EasyMock.geq(expectedValue);463  }464  /**465   * Expects a {@code float} argument greater than or equal to the given value as a parameter466   * to a mocked method.467   * 468   * Use this to loosen the expectations of acceptable parameters for a mocked method call.469   * 470   * If this method is used for anything other than to set a parameter expectation as part of a471   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.472   * 473   * E.g.474   * {@code AndroidMock.expect(mock.getString(AndroidMock.geq(42.0f))).andReturn("hello");}475   * 476   * @param expectedValue the value to which the specified incoming parameter to the mocked method477   * must be greater than or equal.478   * @return {@code 0}. The return value is always ignored.479   */480  public static float geq(float expectedValue) {481    return EasyMock.geq(expectedValue);482  }483  /**484   * Expects an {@code int} argument greater than or equal to the given value as a parameter485   * to a mocked method.486   * 487   * Use this to loosen the expectations of acceptable parameters for a mocked method call.488   * 489   * If this method is used for anything other than to set a parameter expectation as part of a490   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.491   * 492   * E.g.493   * {@code AndroidMock.expect(mock.getString(AndroidMock.geq(42))).andReturn("hello");}494   * 495   * @param expectedValue the value to which the specified incoming parameter to the mocked method496   * must be greater than or equal.497   * @return {@code 0}. The return value is always ignored.498   */499  public static int geq(int expectedValue) {500    return EasyMock.geq(expectedValue);501  }502  /**503   * Expects a {@code long} argument greater than or equal to the given value as a parameter504   * to a mocked method.505   * 506   * Use this to loosen the expectations of acceptable parameters for a mocked method call.507   * 508   * If this method is used for anything other than to set a parameter expectation as part of a509   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.510   * 511   * E.g.512   * {@code AndroidMock.expect(mock.getString(AndroidMock.geq(42l))).andReturn("hello");}513   * 514   * @param expectedValue the value to which the specified incoming parameter to the mocked method515   * must be greater than or equal.516   * @return {@code 0}. The return value is always ignored.517   */518  public static long geq(long expectedValue) {519    return EasyMock.geq(expectedValue);520  }521  /**522   * Expects a {@code short} argument greater than or equal to the given value as a parameter523   * to a mocked method.524   * 525   * Use this to loosen the expectations of acceptable parameters for a mocked method call.526   * 527   * If this method is used for anything other than to set a parameter expectation as part of a528   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.529   * 530   * E.g.531   * {@code AndroidMock.expect(mock.getString(AndroidMock.geq((short)42))).andReturn("hello");}532   * 533   * @param expectedValue the value to which the specified incoming parameter to the mocked method534   * must be greater than or equal.535   * @return {@code 0}. The return value is always ignored.536   */537  public static short geq(short expectedValue) {538    return EasyMock.geq(expectedValue);539  }540  /**541   * Expects a {@code Comparable} argument less than or equal to the given value as a parameter542   * to a mocked method.543   * 544   * Use this to loosen the expectations of acceptable parameters for a mocked method call.545   * 546   * If this method is used for anything other than to set a parameter expectation as part of a547   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.548   * 549   * E.g.550   * {@code AndroidMock.expect(mock.getString(AndroidMock.leq("hi"))).andReturn("hello");}551   * 552   * @param expectedValue the value to which the specified incoming parameter to the mocked method553   * must be less than or equal.554   * @return {@code null}. The return value is always ignored.555   */556  public static <T extends Comparable<T>> T leq(Comparable<T> expectedValue) {557    return EasyMock.leq(expectedValue);558  }559  /**560   * Expects a {@code byte} argument less than or equal to the given value as a parameter561   * to a mocked method.562   * 563   * Use this to loosen the expectations of acceptable parameters for a mocked method call.564   * 565   * If this method is used for anything other than to set a parameter expectation as part of a566   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.567   * 568   * E.g.569   * {@code AndroidMock.expect(mock.getString(AndroidMock.leq((byte)42))).andReturn("hello");}570   * 571   * @param expectedValue the value to which the specified incoming parameter to the mocked method572   * must be less than or equal.573   * @return {@code 0}. The return value is always ignored.574   */575  public static byte leq(byte expectedValue) {576    return EasyMock.leq(expectedValue);577  }578  /**579   * Expects a {@code double} argument less than or equal to the given value as a parameter580   * to a mocked method.581   * 582   * Use this to loosen the expectations of acceptable parameters for a mocked method call.583   * 584   * If this method is used for anything other than to set a parameter expectation as part of a585   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.586   * 587   * E.g.588   * {@code AndroidMock.expect(mock.getString(AndroidMock.leq(42.0))).andReturn("hello");}589   * 590   * @param expectedValue the value to which the specified incoming parameter to the mocked method591   * must be less than or equal.592   * @return {@code 0}. The return value is always ignored.593   */594  public static double leq(double expectedValue) {595    return EasyMock.leq(expectedValue);596  }597  /**598   * Expects a {@code float} argument less than or equal to the given value as a parameter599   * to a mocked method.600   * 601   * Use this to loosen the expectations of acceptable parameters for a mocked method call.602   * 603   * If this method is used for anything other than to set a parameter expectation as part of a604   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.605   * 606   * E.g.607   * {@code AndroidMock.expect(mock.getString(AndroidMock.leq(42.0f))).andReturn("hello");}608   * 609   * @param expectedValue the value to which the specified incoming parameter to the mocked method610   * must be less than or equal.611   * @return {@code 0}. The return value is always ignored.612   */613  public static float leq(float expectedValue) {614    return EasyMock.leq(expectedValue);615  }616  /**617   * Expects an {@code int} argument less than or equal to the given value as a parameter618   * to a mocked method.619   * 620   * Use this to loosen the expectations of acceptable parameters for a mocked method call.621   * 622   * If this method is used for anything other than to set a parameter expectation as part of a623   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.624   * 625   * E.g.626   * {@code AndroidMock.expect(mock.getString(AndroidMock.leq(42))).andReturn("hello");}627   * 628   * @param expectedValue the value to which the specified incoming parameter to the mocked method629   * must be less than or equal.630   * @return {@code 0}. The return value is always ignored.631   */632  public static int leq(int expectedValue) {633    return EasyMock.leq(expectedValue);634  }635  /**636   * Expects a {@code long} argument less than or equal to the given value as a parameter637   * to a mocked method.638   * 639   * Use this to loosen the expectations of acceptable parameters for a mocked method call.640   * 641   * If this method is used for anything other than to set a parameter expectation as part of a642   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.643   * 644   * E.g.645   * {@code AndroidMock.expect(mock.getString(AndroidMock.leq(42l))).andReturn("hello");}646   * 647   * @param expectedValue the value to which the specified incoming parameter to the mocked method648   * must be less than or equal.649   * @return {@code 0}. The return value is always ignored.650   */651  public static long leq(long expectedValue) {652    return EasyMock.leq(expectedValue);653  }654  /**655   * Expects a {@code short} argument less than or equal to the given value as a parameter656   * to a mocked method.657   * 658   * Use this to loosen the expectations of acceptable parameters for a mocked method call.659   * 660   * If this method is used for anything other than to set a parameter expectation as part of a661   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.662   * 663   * E.g.664   * {@code AndroidMock.expect(mock.getString(AndroidMock.leq((short)42))).andReturn("hello");}665   * 666   * @param expectedValue the value to which the specified incoming parameter to the mocked method667   * must be less than or equal.668   * @return {@code 0}. The return value is always ignored.669   */670  public static short leq(short expectedValue) {671    return EasyMock.leq(expectedValue);672  }673  /**674   * Expects a {@code Comparable} argument greater than the given value as a parameter675   * to a mocked method.676   * 677   * Use this to loosen the expectations of acceptable parameters for a mocked method call.678   * 679   * If this method is used for anything other than to set a parameter expectation as part of a680   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.681   * 682   * E.g.683   * {@code AndroidMock.expect(mock.getString(AndroidMock.gt("hi"))).andReturn("hello");}684   * 685   * @param expectedValue the value to which the specified incoming parameter to the mocked method686   * must be greater than.687   * @return {@code null}. The return value is always ignored.688   */689  public static <T extends Comparable<T>> T gt(Comparable<T> expectedValue) {690    return EasyMock.gt(expectedValue);691  }692  /**693   * Expects a {@code byte} argument greater than the given value as a parameter694   * to a mocked method.695   * 696   * Use this to loosen the expectations of acceptable parameters for a mocked method call.697   * 698   * If this method is used for anything other than to set a parameter expectation as part of a699   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.700   * 701   * E.g.702   * {@code AndroidMock.expect(mock.getString(AndroidMock.gt((byte)42))).andReturn("hello");}703   * 704   * @param expectedValue the value to which the specified incoming parameter to the mocked method705   * must be greater than.706   * @return {@code 0}. The return value is always ignored.707   */708  public static byte gt(byte expectedValue) {709    return EasyMock.gt(expectedValue);710  }711  /**712   * Expects a {@code double} argument greater than the given value as a parameter713   * to a mocked method.714   * 715   * Use this to loosen the expectations of acceptable parameters for a mocked method call.716   * 717   * If this method is used for anything other than to set a parameter expectation as part of a718   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.719   * 720   * E.g.721   * {@code AndroidMock.expect(mock.getString(AndroidMock.gt(42.0))).andReturn("hello");}722   * 723   * @param expectedValue the value to which the specified incoming parameter to the mocked method724   * must be greater than.725   * @return {@code 0}. The return value is always ignored.726   */727  public static double gt(double expectedValue) {728    return EasyMock.gt(expectedValue);729  }730  /**731   * Expects a {@code float} argument greater than the given value as a parameter732   * to a mocked method.733   * 734   * Use this to loosen the expectations of acceptable parameters for a mocked method call.735   * 736   * If this method is used for anything other than to set a parameter expectation as part of a737   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.738   * 739   * E.g.740   * {@code AndroidMock.expect(mock.getString(AndroidMock.gt(42.0f))).andReturn("hello");}741   * 742   * @param expectedValue the value to which the specified incoming parameter to the mocked method743   * must be greater than.744   * @return {@code 0}. The return value is always ignored.745   */746  public static float gt(float expectedValue) {747    return EasyMock.gt(expectedValue);748  }749  /**750   * Expects an {@code int} argument greater than the given value as a parameter751   * to a mocked method.752   * 753   * Use this to loosen the expectations of acceptable parameters for a mocked method call.754   * 755   * If this method is used for anything other than to set a parameter expectation as part of a756   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.757   * 758   * E.g.759   * {@code AndroidMock.expect(mock.getString(AndroidMock.gt(42))).andReturn("hello");}760   * 761   * @param expectedValue the value to which the specified incoming parameter to the mocked method762   * must be greater than.763   * @return {@code 0}. The return value is always ignored.764   */765  public static int gt(int expectedValue) {766    return EasyMock.gt(expectedValue);767  }768  /**769   * Expects a {@code long} argument greater than the given value as a parameter770   * to a mocked method.771   * 772   * Use this to loosen the expectations of acceptable parameters for a mocked method call.773   * 774   * If this method is used for anything other than to set a parameter expectation as part of a775   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.776   * 777   * E.g.778   * {@code AndroidMock.expect(mock.getString(AndroidMock.gt(42l))).andReturn("hello");}779   * 780   * @param expectedValue the value to which the specified incoming parameter to the mocked method781   * must be greater than.782   * @return {@code 0}. The return value is always ignored.783   */784  public static long gt(long expectedValue) {785    return EasyMock.gt(expectedValue);786  }787  /**788   * Expects a {@code short} argument greater than the given value as a parameter789   * to a mocked method.790   * 791   * Use this to loosen the expectations of acceptable parameters for a mocked method call.792   * 793   * If this method is used for anything other than to set a parameter expectation as part of a794   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.795   * 796   * E.g.797   * {@code AndroidMock.expect(mock.getString(AndroidMock.gt((short)42))).andReturn("hello");}798   * 799   * @param expectedValue the value to which the specified incoming parameter to the mocked method800   * must be greater than.801   * @return {@code 0}. The return value is always ignored.802   */803  public static short gt(short expectedValue) {804    return EasyMock.gt(expectedValue);805  }806  /**807   * Expects a {@code Comparable} argument less than the given value as a parameter808   * to a mocked method.809   * 810   * Use this to loosen the expectations of acceptable parameters for a mocked method call.811   * 812   * If this method is used for anything other than to set a parameter expectation as part of a813   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.814   * 815   * E.g.816   * {@code AndroidMock.expect(mock.getString(AndroidMock.lt("hi"))).andReturn("hello");}817   * 818   * @param expectedValue the value to which the specified incoming parameter to the mocked method819   * must be less than.820   * @return {@code null}. The return value is always ignored.821   */822  public static <T extends Comparable<T>> T lt(Comparable<T> expectedValue) {823    return EasyMock.lt(expectedValue);824  }825  /**826   * Expects a {@code byte} argument less than the given value as a parameter827   * to a mocked method.828   * 829   * Use this to loosen the expectations of acceptable parameters for a mocked method call.830   * 831   * If this method is used for anything other than to set a parameter expectation as part of a832   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.833   * 834   * E.g.835   * {@code AndroidMock.expect(mock.getString(AndroidMock.lt((byte)42))).andReturn("hello");}836   * 837   * @param expectedValue the value to which the specified incoming parameter to the mocked method838   * must be less than.839   * @return {@code 0}. The return value is always ignored.840   */841  public static byte lt(byte expectedValue) {842    return EasyMock.lt(expectedValue);843  }844  /**845   * Expects a {@code double} argument less than the given value as a parameter846   * to a mocked method.847   * 848   * Use this to loosen the expectations of acceptable parameters for a mocked method call.849   * 850   * If this method is used for anything other than to set a parameter expectation as part of a851   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.852   * 853   * E.g.854   * {@code AndroidMock.expect(mock.getString(AndroidMock.lt(42.0))).andReturn("hello");}855   * 856   * @param expectedValue the value to which the specified incoming parameter to the mocked method857   * must be less than.858   * @return {@code 0}. The return value is always ignored.859   */860  public static double lt(double expectedValue) {861    return EasyMock.lt(expectedValue);862  }863  /**864   * Expects a {@code float} argument less than the given value as a parameter865   * to a mocked method.866   * 867   * Use this to loosen the expectations of acceptable parameters for a mocked method call.868   * 869   * If this method is used for anything other than to set a parameter expectation as part of a870   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.871   * 872   * E.g.873   * {@code AndroidMock.expect(mock.getString(AndroidMock.lt(42.0f))).andReturn("hello");}874   * 875   * @param expectedValue the value to which the specified incoming parameter to the mocked method876   * must be less than.877   * @return {@code 0}. The return value is always ignored.878   */879  public static float lt(float expectedValue) {880    return EasyMock.lt(expectedValue);881  }882  /**883   * Expects an {@code int} argument less than the given value as a parameter884   * to a mocked method.885   * 886   * Use this to loosen the expectations of acceptable parameters for a mocked method call.887   * 888   * If this method is used for anything other than to set a parameter expectation as part of a889   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.890   * 891   * E.g.892   * {@code AndroidMock.expect(mock.getString(AndroidMock.lt(42))).andReturn("hello");}893   * 894   * @param expectedValue the value to which the specified incoming parameter to the mocked method895   * must be less than.896   * @return {@code 0}. The return value is always ignored.897   */898  public static int lt(int expectedValue) {899    return EasyMock.lt(expectedValue);900  }901  /**902   * Expects a {@code long} argument less than the given value as a parameter903   * to a mocked method.904   * 905   * Use this to loosen the expectations of acceptable parameters for a mocked method call.906   * 907   * If this method is used for anything other than to set a parameter expectation as part of a908   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.909   * 910   * E.g.911   * {@code AndroidMock.expect(mock.getString(AndroidMock.lt(42l))).andReturn("hello");}912   * 913   * @param expectedValue the value to which the specified incoming parameter to the mocked method914   * must be less than.915   * @return {@code 0}. The return value is always ignored.916   */917  public static long lt(long expectedValue) {918    return EasyMock.lt(expectedValue);919  }920  /**921   * Expects a {@code short} argument less than the given value as a parameter922   * to a mocked method.923   * 924   * Use this to loosen the expectations of acceptable parameters for a mocked method call.925   * 926   * If this method is used for anything other than to set a parameter expectation as part of a927   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.928   * 929   * E.g.930   * {@code AndroidMock.expect(mock.getString(AndroidMock.lt((short)42))).andReturn("hello");}931   * 932   * @param expectedValue the value to which the specified incoming parameter to the mocked method933   * must be less than.934   * @return {@code 0}. The return value is always ignored.935   */936  public static short lt(short expectedValue) {937    return EasyMock.lt(expectedValue);938  }939  /**940   * Expects an object implementing the given class as a parameter to a mocked method. During941   * replay mode, the mocked method call will accept any {@code Object} that is an instance of942   * the specified class or one of its subclasses. Specifically, any {@code non-null} parameter for943   * which the {@code java.lang.Class.isAssignableFrom(Class)} will return true will be accepted by944   * this matcher during the replay phase.945   * 946   * Use this to loosen the expectations of acceptable parameters for a mocked method call.947   * 948   * If this method is used for anything other than to set a parameter expectation as part of a949   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.950   * 951   * E.g.952   * {@code AndroidMock.expect(mock.getString(AndroidMock.isA(HashMap.class))).andReturn("hello");}953   * 954   * @param <T> the expected Class type.955   * @param clazz the class of the accepted type.956   * @return {@code null}. The return value is always ignored.957   */958  public static <T> T isA(Class<T> clazz) {959    return EasyMock.isA(clazz);960  }961  /**962   * Expects a string that contains the given substring as a parameter to a mocked method.963   * During replay mode, the mocked method will accept any {@code non-null String} which contains964   * the provided {@code substring}.965   * 966   * Use this to loosen the expectations of acceptable parameters for a mocked method call.967   * 968   * If this method is used for anything other than to set a parameter expectation as part of a969   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.970   * 971   * E.g.972   * {@code AndroidMock.expect(mock.getString(AndroidMock.substring("hi"))).andReturn("hello");}973   * 974   * @param substring the substring which any incoming parameter to the mocked method must contain.975   * @return {@code null}.976   */977  public static String contains(String substring) {978    return EasyMock.contains(substring);979  }980  /**981   * Expects a {@code boolean} parameter that matches both of the provided expectations. During982   * replay mode, the mocked method will accept any {@code boolean} that matches both of the983   * provided expectations. Possible expectations for {@code first} and {@code second} include (but984   * are not limited to) {@link #anyBoolean()} and {@link #eq(boolean)}.985   * 986   * E.g.987   * {@code AndroidMock.expect(mock.getString(988   *        AndroidMock.and(AndroidMock.anyBoolean(), AndroidMock.eq(true)))).andReturn("hello");}989   * 990   * Or, for illustration purposes (using static imports)991   * 992   * {@code expect(mock.getString(and(anyBoolean(), eq(true)))).andReturn("hello");}993   * 994   * If this method is used for anything other than to set a parameter expectation as part of a995   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.996   * 997   * @param first the first expectation to test.998   * @param second the second expectation to test.999   * @return {@code false}. The return value is always ignored.1000   */1001  public static boolean and(boolean first, boolean second) {1002    return EasyMock.and(first, second);1003  }1004  /**1005   * Expects a {@code byte} parameter that matches both of the provided expectations. During replay1006   * mode, the mocked method will accept any {@code byte} that matches both of the provided1007   * expectations. Possible expectations for {@code first} and {@code second} include (but are not1008   * limited to) {@link #anyByte()}, {@link #leq(byte)} and {@link #eq(byte)}.1009   * 1010   * E.g.1011   * {@code AndroidMock.expect(mock.getString(AndroidMock.and(1012   *        AndroidMock.gt((byte)0), AndroidMock.lt((byte)42)))).andReturn("hello");}1013   * 1014   * Or, for illustration purposes (using static imports)1015   * 1016   * {@code expect(mock.getString(and(gt((byte)0), lt((byte)42)))).andReturn("hello");}1017   * 1018   * If this method is used for anything other than to set a parameter expectation as part of a1019   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1020   * 1021   * @param first the first expectation to test.1022   * @param second the second expectation to test.1023   * @return {@code 0}. The return value is always ignored.1024   */1025  public static byte and(byte first, byte second) {1026    return EasyMock.and(first, second);1027  }1028  /**1029   * Expects a {@code char} parameter that matches both of the provided expectations. During replay1030   * mode, the mocked method will accept any {@code char} that matches both of the provided1031   * expectations. Possible expectations for {@code first} and {@code second} include (but are not1032   * limited to) {@link #anyChar()} and {@link #eq(char)}.1033   * 1034   * E.g.1035   * {@code AndroidMock.expect(mock.getString(1036   *        AndroidMock.and(AndroidMock.geq('a'), AndroidMock.lt('q')))).andReturn("hello");}1037   * 1038   * Or, for illustration purposes (using static imports)1039   * 1040   * {@code expect(mock.getString(and(eq('a'), anyChar()))).andReturn("hello");}1041   * 1042   * If this method is used for anything other than to set a parameter expectation as part of a1043   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1044   * 1045   * @param first the first expectation to test.1046   * @param second the second expectation to test.1047   * @return {@code 0}. The return value is always ignored.1048   */1049  public static char and(char first, char second) {1050    return EasyMock.and(first, second);1051  }1052  /**1053   * Expects a {@code double} parameter that matches both of the provided expectations. During1054   * replay mode, the mocked method will accept any {@code double} that matches both of the provided1055   * expectations. Possible expectations for {@code first} and {@code second} include (but are not1056   * limited to) {@link #anyDouble()}, {@link #leq(double)} and {@link #eq(double)}.1057   * 1058   * E.g.1059   * {@code AndroidMock.expect(mock.getString(1060   *        AndroidMock.and(AndroidMock.gt(0.0), AndroidMock.lt(42.0)))).andReturn("hello");}1061   * 1062   * Or, for illustration purposes (using static imports)1063   * 1064   * {@code expect(mock.getString(and(gt(0.0), lt(42.0)))).andReturn("hello");}1065   * 1066   * If this method is used for anything other than to set a parameter expectation as part of a1067   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1068   * 1069   * @param first the first expectation to test.1070   * @param second the second expectation to test.1071   * @return {@code 0}. The return value is always ignored.1072   */1073  public static double and(double first, double second) {1074    return EasyMock.and(first, second);1075  }1076  /**1077   * Expects a {@code float} parameter that matches both of the provided expectations. During1078   * replay mode, the mocked method will accept any {@code float} that matches both of the provided1079   * expectations. Possible expectations for {@code first} and {@code second} include (but are not1080   * limited to) {@link #anyFloat()}, {@link #leq(float)} and {@link #eq(float)}.1081   * 1082   * E.g.1083   * {@code AndroidMock.expect(mock.getString(1084   *        AndroidMock.and(AndroidMock.gt(0.0f), AndroidMock.lt(42.0f)))).andReturn("hello");}1085   * 1086   * Or, for illustration purposes (using static imports)1087   * 1088   * {@code expect(mock.getString(and(gt(0.0f), lt(42.0f)))).andReturn("hello");}1089   * 1090   * If this method is used for anything other than to set a parameter expectation as part of a1091   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1092   * 1093   * @param first the first expectation to test.1094   * @param second the second expectation to test.1095   * @return {@code 0}. The return value is always ignored.1096   */1097  public static float and(float first, float second) {1098    return EasyMock.and(first, second);1099  }1100  /**1101   * Expects an {@code int} parameter that matches both of the provided expectations. During1102   * replay mode, the mocked method will accept any {@code int} that matches both of the provided1103   * expectations. Possible expectations for {@code first} and {@code second} include (but are not1104   * limited to) {@link #anyInt()}, {@link #leq(int)} and {@link #eq(int)}.1105   * 1106   * E.g.1107   * {@code AndroidMock.expect(mock.getString(1108   *        AndroidMock.and(AndroidMock.gt(0), AndroidMock.lt(42)))).andReturn("hello");}1109   * 1110   * Or, for illustration purposes (using static imports)1111   * 1112   * {@code expect(mock.getString(and(gt(0), lt(42)))).andReturn("hello");}1113   * 1114   * If this method is used for anything other than to set a parameter expectation as part of a1115   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1116   * 1117   * @param first the first expectation to test.1118   * @param second the second expectation to test.1119   * @return {@code 0}. The return value is always ignored.1120   */1121  public static int and(int first, int second) {1122    return EasyMock.and(first, second);1123  }1124  /**1125   * Expects a {@code long} parameter that matches both of the provided expectations. During1126   * replay mode, the mocked method will accept any {@code long} that matches both of the provided1127   * expectations. Possible expectations for {@code first} and {@code second} include (but are not1128   * limited to) {@link #anyLong()}, {@link #leq(long)} and {@link #eq(long)}.1129   * 1130   * E.g.1131   * {@code AndroidMock.expect(mock.getString(1132   *        AndroidMock.and(AndroidMock.gt(0l), AndroidMock.lt(42l)))).andReturn("hello");}1133   * 1134   * Or, for illustration purposes (using static imports)1135   * 1136   * {@code expect(mock.getString(and(gt(0l), lt(42l)))).andReturn("hello");}1137   * 1138   * If this method is used for anything other than to set a parameter expectation as part of a1139   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1140   * 1141   * @param first the first expectation to test.1142   * @param second the second expectation to test.1143   * @return {@code 0}. The return value is always ignored.1144   */1145  public static long and(long first, long second) {1146    return EasyMock.and(first, second);1147  }1148  /**1149   * Expects a {@code short} parameter that matches both of the provided expectations. During1150   * replay mode, the mocked method will accept any {@code short} that matches both of the provided1151   * expectations. Possible expectations for {@code first} and {@code second} include (but are not1152   * limited to) {@link #anyShort()}, {@link #leq(short)} and {@link #eq(short)}.1153   * 1154   * E.g.1155   * {@code AndroidMock.expect(mock.getString(AndroidMock.and(1156   *        AndroidMock.gt((short)0), AndroidMock.lt((short)42)))).andReturn("hello");}1157   * 1158   * Or, for illustration purposes (using static imports)1159   * 1160   * {@code expect(mock.getString(and(gt((short)0), lt((short)42)))).andReturn("hello");}1161   * 1162   * If this method is used for anything other than to set a parameter expectation as part of a1163   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1164   * 1165   * @param first the first expectation to test.1166   * @param second the second expectation to test.1167   * @return {@code 0}. The return value is always ignored.1168   */1169  public static short and(short first, short second) {1170    return EasyMock.and(first, second);1171  }1172  /**1173   * Expects an {@code Object} parameter that matches both of the provided expectations. During1174   * replay mode, the mocked method will accept any {@code Object} that matches both of the provided1175   * expectations. Possible expectations for {@code first} and {@code second} include (but are not1176   * limited to) {@link #anyObject()}, {@link #isA(Class)} and {@link #contains(String)}.1177   * 1178   * E.g.1179   * {@code AndroidMock.expect(mock.getString(1180   *        AndroidMock.and(1181   *            AndroidMock.contains("hi"), AndroidMock.contains("world")))).andReturn("hello");}1182   * 1183   * Or, for illustration purposes (using static imports)1184   * 1185   * {@code expect(mock.getString(and(contains("hi"), contains("world")))).andReturn("hello");}1186   * 1187   * If this method is used for anything other than to set a parameter expectation as part of a1188   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1189   * 1190   * @param first the first expectation to test.1191   * @param second the second expectation to test.1192   * @return {@code 0}. The return value is always ignored.1193   */1194  public static <T> T and(T first, T second) {1195    return EasyMock.and(first, second);1196  }1197  /**1198   * Expects a {@code boolean} parameter that matches one or both of the provided expectations.1199   * During replay mode, the mocked method will accept any {@code boolean} that matches one of the1200   * provided expectations, or both of them. Possible expectations for {@code first} and1201   * {@code second} include (but are not limited to) {@link #anyBoolean()} and {@link #eq(boolean)}.1202   * 1203   * E.g.1204   * {@code AndroidMock.expect(mock.getString(1205   *        AndroidMock.or(AndroidMock.eq(true), AndroidMock.anyBoolean()))).andReturn("hello");}1206   * 1207   * Or, for illustration purposes (using static imports)1208   * 1209   * {@code expect(mock.getString(and(eq(true), anyBoolean()))).andReturn("hello");}1210   * 1211   * If this method is used for anything other than to set a parameter expectation as part of a1212   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1213   * 1214   * @param first the first expectation to test.1215   * @param second the second expectation to test.1216   * @return {@code false}. The return value is always ignored.1217   */1218  public static boolean or(boolean first, boolean second) {1219    return EasyMock.or(first, second);1220  }1221  /**1222   * Expects a {@code byte} parameter that matches one or both of the provided expectations.1223   * During replay mode, the mocked method will accept any {@code byte} that matches one of the1224   * provided expectations, or both of them. Possible expectations for {@code first} and1225   * {@code second} include (but are not limited to) {@link #anyByte()}, {@link #eq(byte)},1226   * and {@link #lt(byte)}.1227   * 1228   * E.g.1229   * {@code AndroidMock.expect(mock.getString(AndroidMock.or(1230   *        AndroidMock.geq((byte)0), AndroidMock.lt((byte)42)))).andReturn("hello");}1231   * 1232   * Or, for illustration purposes (using static imports)1233   * 1234   * {@code expect(mock.getString(or(geq((byte)0), lt((byte)42)))).andReturn("hello");}1235   * 1236   * If this method is used for anything other than to set a parameter expectation as part of a1237   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1238   * 1239   * @param first the first expectation to test.1240   * @param second the second expectation to test.1241   * @return {@code 0}. The return value is always ignored.1242   */1243  public static byte or(byte first, byte second) {1244    return EasyMock.or(first, second);1245  }1246  /**1247   * Expects a {@code char} parameter that matches one or both of the provided expectations.1248   * During replay mode, the mocked method will accept any {@code char} that matches one of the1249   * provided expectations, or both of them. Possible expectations for {@code first} and1250   * {@code second} include (but are not limited to) {@link #anyChar()} and {@link #eq(char)}.1251   * 1252   * E.g.1253   * {@code AndroidMock.expect(mock.getString(AndroidMock.or(1254   *        AndroidMock.eq('a'), AndroidMock.eq('z')))).andReturn("hello");}1255   * 1256   * Or, for illustration purposes (using static imports)1257   * 1258   * {@code expect(mock.getString(or(eq('a'), eq('z')))).andReturn("hello");}1259   * 1260   * If this method is used for anything other than to set a parameter expectation as part of a1261   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1262   * 1263   * @param first the first expectation to test.1264   * @param second the second expectation to test.1265   * @return {@code 0}. The return value is always ignored.1266   */1267  public static char or(char first, char second) {1268    return EasyMock.or(first, second);1269  }1270  /**1271   * Expects a {@code double} parameter that matches one or both of the provided expectations.1272   * During replay mode, the mocked method will accept any {@code double} that matches one of the1273   * provided expectations, or both of them. Possible expectations for {@code first} and1274   * {@code second} include (but are not limited to) {@link #anyDouble()}, {@link #eq(double)}1275   * and {@link #lt(double)}.1276   * 1277   * E.g.1278   * {@code AndroidMock.expect(mock.getString(AndroidMock.or(1279   *        AndroidMock.eq(0.0), AndroidMock.geq(42.0)))).andReturn("hello");}1280   * 1281   * Or, for illustration purposes (using static imports)1282   * 1283   * {@code expect(mock.getString(or(eq(0.0), geq(42.0)))).andReturn("hello");}1284   * 1285   * If this method is used for anything other than to set a parameter expectation as part of a1286   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1287   * 1288   * @param first the first expectation to test.1289   * @param second the second expectation to test.1290   * @return {@code 0}. The return value is always ignored.1291   */1292  public static double or(double first, double second) {1293    return EasyMock.or(first, second);1294  }1295  /**1296   * Expects a {@code float} parameter that matches one or both of the provided expectations.1297   * During replay mode, the mocked method will accept any {@code float} that matches one of the1298   * provided expectations, or both of them. Possible expectations for {@code first} and1299   * {@code second} include (but are not limited to) {@link #anyFloat()}, {@link #eq(float)}1300   * and {@link #lt(float)}.1301   * 1302   * E.g.1303   * {@code AndroidMock.expect(mock.getString(AndroidMock.or(1304   *        AndroidMock.eq(0.0f), AndroidMock.geq(42.0f)))).andReturn("hello");}1305   * 1306   * Or, for illustration purposes (using static imports)1307   * 1308   * {@code expect(mock.getString(or(eq(0.0f), geq(42.0f)))).andReturn("hello");}1309   * 1310   * If this method is used for anything other than to set a parameter expectation as part of a1311   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1312   * 1313   * @param first the first expectation to test.1314   * @param second the second expectation to test.1315   * @return {@code 0}. The return value is always ignored.1316   */1317  public static float or(float first, float second) {1318    return EasyMock.or(first, second);1319  }1320  /**1321   * Expects an {@code int} parameter that matches one or both of the provided expectations.1322   * During replay mode, the mocked method will accept any {@code int} that matches one of the1323   * provided expectations, or both of them. Possible expectations for {@code first} and1324   * {@code second} include (but are not limited to) {@link #anyInt()}, {@link #eq(int)}1325   * and {@link #lt(int)}.1326   * 1327   * E.g.1328   * {@code AndroidMock.expect(mock.getString(AndroidMock.or(1329   *        AndroidMock.eq(0), AndroidMock.geq(42)))).andReturn("hello");}1330   * 1331   * Or, for illustration purposes (using static imports)1332   * 1333   * {@code expect(mock.getString(or(eq(0), geq(42)))).andReturn("hello");}1334   * 1335   * If this method is used for anything other than to set a parameter expectation as part of a1336   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1337   * 1338   * @param first the first expectation to test.1339   * @param second the second expectation to test.1340   * @return {@code 0}. The return value is always ignored.1341   */1342  public static int or(int first, int second) {1343    return EasyMock.or(first, second);1344  }1345  /**1346   * Expects a {@code long} parameter that matches one or both of the provided expectations.1347   * During replay mode, the mocked method will accept any {@code long} that matches one of the1348   * provided expectations, or both of them. Possible expectations for {@code first} and1349   * {@code second} include (but are not limited to) {@link #anyLong()}, {@link #eq(long)}1350   * and {@link #lt(long)}.1351   * 1352   * E.g.1353   * {@code AndroidMock.expect(mock.getString(AndroidMock.or(1354   *        AndroidMock.eq(0l), AndroidMock.geq(42l)))).andReturn("hello");}1355   * 1356   * Or, for illustration purposes (using static imports)1357   * 1358   * {@code expect(mock.getString(or(eq(0l), geq(42l)))).andReturn("hello");}1359   * 1360   * If this method is used for anything other than to set a parameter expectation as part of a1361   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1362   * 1363   * @param first the first expectation to test.1364   * @param second the second expectation to test.1365   * @return {@code 0}. The return value is always ignored.1366   */1367  public static long or(long first, long second) {1368    return EasyMock.or(first, second);1369  }1370  /**1371   * Expects a {@code short} parameter that matches one or both of the provided expectations.1372   * During replay mode, the mocked method will accept any {@code short} that matches one of the1373   * provided expectations, or both of them. Possible expectations for {@code first} and1374   * {@code second} include (but are not limited to) {@link #anyShort()}, {@link #eq(short)}1375   * and {@link #lt(short)}.1376   * 1377   * E.g.1378   * {@code AndroidMock.expect(mock.getString(AndroidMock.or(1379   *        AndroidMock.eq((short)0), AndroidMock.geq((short)42)))).andReturn("hello");}1380   * 1381   * Or, for illustration purposes (using static imports)1382   * 1383   * {@code expect(mock.getString(or(eq((short)0), geq((short)42)))).andReturn("hello");}1384   * 1385   * If this method is used for anything other than to set a parameter expectation as part of a1386   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1387   * 1388   * @param first the first expectation to test.1389   * @param second the second expectation to test.1390   * @return {@code 0}. The return value is always ignored.1391   */1392  public static short or(short first, short second) {1393    return EasyMock.or(first, second);1394  }1395  /**1396   * Expects an {@code Object} parameter that matches one or both of the provided expectations.1397   * During replay mode, the mocked method will accept any {@code Object} that matches one of the1398   * provided expectations, or both of them. Possible expectations for {@code first} and1399   * {@code second} include (but are not limited to) {@link #anyObject()}, {@link #eq(Class)}1400   * and {@link #lt(Comparable)}.1401   * 1402   * E.g.1403   * {@code AndroidMock.expect(mock.getString(AndroidMock.or(1404   *        AndroidMock.notNull(), AndroidMock.geq(fortyTwo)))).andReturn("hello");}1405   * 1406   * Or, for illustration purposes (using static imports)1407   * 1408   * {@code expect(mock.getString(or(notNull(), geq(fortyTwo)))).andReturn("hello");}1409   * 1410   * If this method is used for anything other than to set a parameter expectation as part of a1411   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1412   * 1413   * @param first the first expectation to test.1414   * @param second the second expectation to test.1415   * @return {@code null}. The return value is always ignored.1416   */1417  public static <T> T or(T first, T second) {1418    return EasyMock.or(first, second);1419  }1420  /**1421   * Expects a {@code boolean} parameter that does not match the provided expectation.1422   * During replay mode, the mocked method will accept any {@code boolean} that does not match1423   * the provided expectation. Possible expectations for {@code expectation}1424   * include (but are not limited to) {@link #anyBoolean()} and {@link #eq(boolean)}.1425   * 1426   * E.g.1427   * {@code AndroidMock.expect(mock.getString(1428   *        AndroidMock.not(AndroidMock.eq(true)))).andReturn("hello");}1429   * 1430   * Or, for illustration purposes (using static imports)1431   * 1432   * {@code expect(mock.getString(not(eq(true)))).andReturn("hello");}1433   * 1434   * If this method is used for anything other than to set a parameter expectation as part of a1435   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1436   * 1437   * @param expectation the expectation to test.1438   * @return {@code false}. The return value is always ignored.1439   */1440  public static boolean not(boolean expectation) {1441    return EasyMock.not(expectation);1442  }1443  /**1444   * Expects a {@code byte} parameter that does not match the provided expectation.1445   * During replay mode, the mocked method will accept any {@code byte} that does not match1446   * the provided expectation. Possible expectations for {@code expectation}1447   * include (but are not limited to) {@link #anyByte()}, {@link #eq(byte)} and1448   * {@link #lt(byte)}.1449   * 1450   * E.g.1451   * {@code AndroidMock.expect(mock.getString(1452   *        AndroidMock.not(AndroidMock.eq((byte)42)))).andReturn("hello");}1453   * 1454   * Or, for illustration purposes (using static imports)1455   * 1456   * {@code expect(mock.getString(not(eq((byte)42)))).andReturn("hello");}1457   * 1458   * If this method is used for anything other than to set a parameter expectation as part of a1459   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1460   * 1461   * @param expectation the expectation to test.1462   * @return {@code 0}. The return value is always ignored.1463   */1464  public static byte not(byte expectation) {1465    return EasyMock.not(expectation);1466  }1467  /**1468   * Expects a {@code char} parameter that does not match the provided expectation.1469   * During replay mode, the mocked method will accept any {@code char} that does not match1470   * the provided expectation. Possible expectations for {@code expectation}1471   * include (but are not limited to) {@link #anyChar()} and {@link #eq(char)}.1472   * 1473   * E.g.1474   * {@code AndroidMock.expect(mock.getString(1475   *        AndroidMock.not(AndroidMock.eq('a')))).andReturn("hello");}1476   * 1477   * Or, for illustration purposes (using static imports)1478   * 1479   * {@code expect(mock.getString(not(eq('a')))).andReturn("hello");}1480   * 1481   * If this method is used for anything other than to set a parameter expectation as part of a1482   * mock object's recording phase, then an {@code IllegalStateException} will be thrown.1483   * 1484   * @param expectation the expectation to test.1485   * @return {@code 0}. The return value is always ignored....

Source:HEMessagePhase3ServiceTest.java

...46		final ArrayList<VMSMessagingSystem> vmsMsgSystemList = new ArrayList<VMSMessagingSystem>();47		final Properties properties = new Properties();48		properties.put(UTILITY_MAXCOUNT, COUNT);49		EasyMock.expect(vmsUtils.loadProperties()).andReturn(properties);50		EasyMock.expect(vmsUtils.removeChar(EasyMock.anyString(), EasyMock.anyChar())).andReturn("123345656567676878");51		EasyMock.expect(schedulerTransDAO.getUnsentMessages(20, 1)).andReturn(vmsMsgSystemList);52		final VendServiceDetails vendSrvc = EasyMock.createMock(VendServiceDetails.class);53		EasyMock.expect(vmsUtils.getVendServiceDetails(EasyMock.anyString())).andReturn(vendSrvc);54		final UnityServiceStub unityServiceStub = EasyMock.createMock(UnityServiceStub.class);55		EasyMock.expect(heCmnService.prepareUnityServiceStub(vendSrvc, url.toString())).andReturn(unityServiceStub);56		final LoginResponse loginRsp = new LoginResponse();57		final LoginResult result = new LoginResult();58		result.setSessionId(SESSION_ID);59		loginRsp.setResult(result);60		EasyMock.expect(heCmnService.loginService(unityServiceStub, vendSrvc)).andReturn(loginRsp);61		heCmnService.logoutService(unityServiceStub, SESSION_ID);62		EasyMock.expectLastCall();63		EasyMock.replay(schedulerTransDAO);64		EasyMock.replay(vmsUtils);...

Source:EasymockListenerRegistrationHandler.java

...60		ANY_FOR_PRIMITIVE_TYPES.put( int.class, EasyMock::anyInt );61		ANY_FOR_PRIMITIVE_TYPES.put( long.class, EasyMock::anyLong );62		ANY_FOR_PRIMITIVE_TYPES.put( float.class, EasyMock::anyFloat );63		ANY_FOR_PRIMITIVE_TYPES.put( double.class, EasyMock::anyDouble );64		ANY_FOR_PRIMITIVE_TYPES.put( char.class, EasyMock::anyChar );65		ANY_FOR_PRIMITIVE_TYPES.put( boolean.class, EasyMock::anyBoolean );66	}67}...

anyChar

Using AI Code Generation

1import org.easymock.EasyMock;2import org.easymock.IArgumentMatcher;3{4    public boolean matches(Object argument)5    {6        return (argument instanceof Character);7    }8    public void appendTo(StringBuffer buffer)9    {10        buffer.append("anyChar()");11    }12}13import org.easymock.EasyMock;14import org.easymock.IArgumentMatcher;15{16    public boolean matches(Object argument)17    {18        return (argument instanceof Character);19    }20    public void appendTo(StringBuffer buffer)21    {22        buffer.append("anyChar()");23    }24}25import org.easymock.EasyMock;26import org.easymock.IArgumentMatcher;27{28    public boolean matches(Object argument)29    {30        return (argument instanceof Character);31    }32    public void appendTo(StringBuffer buffer)33    {34        buffer.append("anyChar()");35    }36}37import org.easymock.EasyMock;38import org.easymock.IArgumentMatcher;39{40    public boolean matches(Object argument)41    {42        return (argument instanceof Character);43    }44    public void appendTo(StringBuffer buffer)45    {46        buffer.append("anyChar()");47    }48}49import org.easymock.EasyMock;50import org.easymock.IArgumentMatcher;51{52    public boolean matches(Object argument)53    {54        return (argument instanceof Character);55    }56    public void appendTo(StringBuffer buffer)57    {58        buffer.append("anyChar()");59    }60}61import org.easymock.EasyMock;62import org.easymock.IArgumentMatcher;

anyChar

Using AI Code Generation

1import org.easymock.EasyMock;2import org.easymock.IMocksControl;3import org.easymock.internal.MocksControl;4public class 1 {5    public static void main(String[] args) {6        IMocksControl control = EasyMock.createControl();7        I1 mock1 = control.createMock(I1.class);8        I2 mock2 = control.createMock(I2.class);9        EasyMock.expect(mock1.m1(anyChar())).andReturn("m1");10        EasyMock.expect(mock2.m2(anyChar())).andReturn("m2");11        control.replay();12        System.out.println(mock1.m1('a'));13        System.out.println(mock2.m2('b'));14        control.verify();15    }16}17public interface I1 {18    String m1(char c);19}20public interface I2 {21    String m2(char c);22}23EasyMock - anyChar() example24EasyMock - anyDouble() example25EasyMock - anyFloat() example26EasyMock - anyInt() example27EasyMock - anyLong() example28EasyMock - anyObject() example29EasyMock - anyShort() example30EasyMock - anyString() example31EasyMock - anyVararg() example32EasyMock - and() example33EasyMock - andAnswer() example34EasyMock - andStubAnswer() example35EasyMock - andStubReturn() example36EasyMock - andStubThrow() example37EasyMock - andThrow() example38EasyMock - anyBoolean() example39EasyMock - anyByte() example40EasyMock - anyChar() example41EasyMock - anyDouble() example42EasyMock - anyFloat() example43EasyMock - anyInt() example44EasyMock - anyLong() example45EasyMock - anyObject() example46EasyMock - anyShort() example47EasyMock - anyString() example48EasyMock - anyVararg() example49EasyMock - and() example50EasyMock - andAnswer() example51EasyMock - andStubAnswer() example52EasyMock - andStubReturn() example53EasyMock - andStubThrow() example54EasyMock - andThrow() example55EasyMock - anyBoolean() example56EasyMock - anyByte() example57EasyMock - anyChar() example58EasyMock - anyDouble() example

anyChar

Using AI Code Generation

1import org.easymock.EasyMock;2import org.easymock.IArgumentMatcher;3import org.junit.Test;4import static org.easymock.EasyMock.*;5import static org.junit.Assert.assertEquals;6public class Test1 {7   public void test1() {8      IMethods mock = mock(IMethods.class);9      expect(mock.add(anyChar(), anyChar())).andReturn(5);10      replay(mock);11      assertEquals(5, mock.add('a', 'b'));12      verify(mock);13   }14}15Next Topic EasyMock anyDouble() method

anyChar

Using AI Code Generation

1import org.easymock.EasyMock;2import org.easymock.IArgumentMatcher;3import org.junit.Test;4import static org.easymock.EasyMock.*;5public class Test1 {6    public void test() {7        I1 mock = createMock(I1.class);8        mock.m(anyChar());9        replay(mock);10        mock.m('a');11        verify(mock);12    }13}14import org.easymock.EasyMock;15import org.easymock.IArgumentMatcher;16import org.junit.Test;17import static org.easymock.EasyMock.*;18public class Test2 {19    public void test() {20        I1 mock = createMock(I1.class);21        mock.m(anyChar());22        replay(mock);23        mock.m('b');24        verify(mock);25    }26}27import org.easymock.EasyMock;28import org.easymock.IArgumentMatcher;29import org.junit.Test;30import static org.easymock.EasyMock.*;31public class Test3 {32    public void test() {33        I1 mock = createMock(I1.class);34        mock.m(anyChar());35        replay(mock);36        mock.m('c');37        verify(mock);38    }39}40import org.easymock.EasyMock;41import org.easymock.IArgumentMatcher;42import org.junit.Test;43import static org.easymock.EasyMock.*;44public class Test4 {45    public void test() {46        I1 mock = createMock(I1.class);47        mock.m(anyChar());

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.