diff options
Diffstat (limited to 'dev-java/easymock/files/easymock-2.5.5-nameClash.patch')
| -rw-r--r-- | dev-java/easymock/files/easymock-2.5.5-nameClash.patch | 230 |
1 files changed, 230 insertions, 0 deletions
diff --git a/dev-java/easymock/files/easymock-2.5.5-nameClash.patch b/dev-java/easymock/files/easymock-2.5.5-nameClash.patch new file mode 100644 index 000000000000..7a4f0d92ab64 --- /dev/null +++ b/dev-java/easymock/files/easymock-2.5.5-nameClash.patch @@ -0,0 +1,230 @@ +--- a/src/main/java/org/easymock/EasyMock.java Thu Feb 23 10:32:43 2012 +0100 ++++ b/src/main/java/org/easymock/EasyMock.java Thu Feb 23 11:25:46 2012 +0100 +@@ -1452,81 +1452,200 @@ + + /** + * Expect any object but captures it for later use. +- * +- * @param <T> Type of the captured object +- * @param captured Where the parameter is captured ++ * ++ * @param <T> ++ * Type of the captured object ++ * @param captured ++ * Where the parameter is captured + * @return <code>null</code> + */ +- public static <T> T capture(Capture<T> captured) { ++ public static <T> T capture(final Capture<T> captured) { + reportMatcher(new Captures<T>(captured)); + return null; + } +- ++ ++ /** ++ * Expect any boolean but captures it for later use. ++ * ++ * @param captured ++ * Where the parameter is captured ++ * @return <code>false</code> ++ */ ++ public static boolean captureBoolean(final Capture<Boolean> captured) { ++ reportMatcher(new Captures<Boolean>(captured)); ++ return false; ++ } ++ ++// /** ++// * Expect any boolean but captures it for later use. ++// * ++// * @param captured ++// * Where the parameter is captured ++// * @return <code>0</code> ++// * ++// * @deprecated Because of harder erasure enforcement, doesn't compile in ++// * Java 7 ++// */ ++// @Deprecated ++// public static boolean capture(final Capture<Boolean> captured) { ++// return captureBoolean(captured); ++// } ++ + /** + * Expect any int but captures it for later use. +- * +- * @param captured Where the parameter is captured ++ * ++ * @param captured ++ * Where the parameter is captured + * @return <code>0</code> + */ +- public static int capture(Capture<Integer> captured) { ++ public static int captureInt(final Capture<Integer> captured) { + reportMatcher(new Captures<Integer>(captured)); + return 0; + } +- ++// /** ++// * Expect any int but captures it for later use. ++// * ++// * @param captured ++// * Where the parameter is captured ++// * @return <code>0</code> ++// * ++// * @deprecated Because of harder erasure enforcement, doesn't compile in ++// * Java 7 ++// */ ++// @Deprecated ++// public static int capture(final Capture<Integer> captured) { ++// return captureInt(captured); ++// } ++ + /** + * Expect any long but captures it for later use. +- * +- * @param captured Where the parameter is captured ++ * ++ * @param captured ++ * Where the parameter is captured + * @return <code>0</code> + */ +- public static long capture(Capture<Long> captured) { ++ public static long captureLong(final Capture<Long> captured) { + reportMatcher(new Captures<Long>(captured)); + return 0; + } +- ++// /** ++// * Expect any long but captures it for later use. ++// * ++// * @param captured ++// * Where the parameter is captured ++// * @return <code>0</code> ++// * ++// * @deprecated Because of harder erasure enforcement, doesn't compile in ++// * Java 7 ++// */ ++// @Deprecated ++// public static long capture(final Capture<Long> captured) { ++// return captureLong(captured); ++// } ++ + /** + * Expect any float but captures it for later use. +- * +- * @param captured Where the parameter is captured ++ * ++ * @param captured ++ * Where the parameter is captured + * @return <code>0</code> + */ +- public static float capture(Capture<Float> captured) { ++ public static float captureFloat(final Capture<Float> captured) { + reportMatcher(new Captures<Float>(captured)); + return 0; + } +- ++// /** ++// * Expect any float but captures it for later use. ++// * ++// * @param captured ++// * Where the parameter is captured ++// * @return <code>0</code> ++// * ++// * @deprecated Because of harder erasure enforcement, doesn't compile in ++// * Java 7 ++// */ ++// @Deprecated ++// public static float capture(final Capture<Float> captured) { ++// return captureFloat(captured); ++// } ++ + /** + * Expect any double but captures it for later use. +- * +- * @param captured Where the parameter is captured ++ * ++ * @param captured ++ * Where the parameter is captured + * @return <code>0</code> + */ +- public static double capture(Capture<Double> captured) { ++ public static double captureDouble(final Capture<Double> captured) { + reportMatcher(new Captures<Double>(captured)); + return 0; + } ++// /** ++// * Expect any double but captures it for later use. ++// * ++// * @param captured ++// * Where the parameter is captured ++// * @return <code>0</code> ++// * ++// * @deprecated Because of harder erasure enforcement, doesn't compile in ++// * Java 7 ++// */ ++// @Deprecated ++// public static double capture(final Capture<Double> captured) { ++// return captureDouble(captured); ++// } + + /** + * Expect any byte but captures it for later use. +- * +- * @param captured Where the parameter is captured ++ * ++ * @param captured ++ * Where the parameter is captured + * @return <code>0</code> + */ +- public static byte capture(Capture<Byte> captured) { ++ public static byte captureByte(final Capture<Byte> captured) { + reportMatcher(new Captures<Byte>(captured)); + return 0; + } +- ++// /** ++// * Expect any byte but captures it for later use. ++// * ++// * @param captured ++// * Where the parameter is captured ++// * @return <code>0</code> ++// * ++// * @deprecated Because of harder erasure enforcement, doesn't compile in ++// * Java 7 ++// */ ++// @Deprecated ++// public static byte capture(final Capture<Byte> captured) { ++// return captureByte(captured); ++// } ++ + /** + * Expect any char but captures it for later use. +- * +- * @param captured Where the parameter is captured ++ * ++ * @param captured ++ * Where the parameter is captured + * @return <code>0</code> + */ +- public static char capture(Capture<Character> captured) { ++ public static char captureChar(final Capture<Character> captured) { + reportMatcher(new Captures<Character>(captured)); + return 0; + } ++// /** ++// * Expect any char but captures it for later use. ++// * ++// * @param captured ++// * Where the parameter is captured ++// * @return <code>0</code> ++// * ++// * @deprecated Because of harder erasure enforcement, doesn't compile in ++// * Java 7 ++// */ ++// @Deprecated ++// public static char capture(final Capture<Character> captured) { ++// return captureChar(captured); ++// } + + /** + * Switches the given mock objects (more exactly: the controls of the mock |