From 15697e114bf8ba229627f43891d67d065778fc3b Mon Sep 17 00:00:00 2001
From: "Volkmar W. Pogatzki" <gentoo@pogatzki.net>
Date: Sun, 11 Sep 2022 13:20:40 +0200
Subject: dev-java/easymock: add 2.5.2

Signed-off-by: Volkmar W. Pogatzki <gentoo@pogatzki.net>
Signed-off-by: Florian Schmaus <flow@gentoo.org>
---
 .../easymock/files/easymock-2.5.5-nameClash.patch  | 230 +++++++++++++++++++++
 1 file changed, 230 insertions(+)
 create mode 100644 dev-java/easymock/files/easymock-2.5.5-nameClash.patch

(limited to 'dev-java/easymock/files/easymock-2.5.5-nameClash.patch')

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
-- 
cgit v1.2.3