[testng] 274/355: Remove duplicate code

Eugene Zhukov eugene-guest at moszumanska.debian.org
Tue Aug 18 10:20:14 UTC 2015


This is an automated email from the git hooks/post-receive script.

eugene-guest pushed a commit to annotated tag OpenBSD
in repository testng.

commit 0dd19bad6ee25a2bd9e84b9a255a002cc95446af
Author: Julien Herr <julien.herr at alcatel-lucent.com>
Date:   Thu May 7 21:38:43 2015 +0200

    Remove duplicate code
---
 src/main/java/org/testng/asserts/Assertion.java | 752 +++---------------------
 1 file changed, 77 insertions(+), 675 deletions(-)

diff --git a/src/main/java/org/testng/asserts/Assertion.java b/src/main/java/org/testng/asserts/Assertion.java
index 7ca9393..743dfcf 100644
--- a/src/main/java/org/testng/asserts/Assertion.java
+++ b/src/main/java/org/testng/asserts/Assertion.java
@@ -67,9 +67,21 @@ public class Assertion implements IAssertLifecycle {
   }
 
   abstract private static class SimpleAssert<T> implements IAssert<T> {
+    private final T actual;
+    private final T expected;
     private final String m_message;
 
     public SimpleAssert(String message) {
+      this(null, null, message);
+    }
+
+    public SimpleAssert(T actual, T expected) {
+      this(actual, expected, null);
+    }
+
+    public SimpleAssert(T actual, T expected, String message) {
+      this.actual = actual;
+      this.expected = expected;
       m_message = message;
     }
 
@@ -80,12 +92,12 @@ public class Assertion implements IAssertLifecycle {
 
     @Override
     public T getActual() {
-        return null;
+        return actual;
     }
 
     @Override
     public T getExpected() {
-        return null;
+        return expected;
     }
 
     @Override
@@ -94,78 +106,38 @@ public class Assertion implements IAssertLifecycle {
 
 
   public void assertTrue(final boolean condition, final String message) {
-    doAssert(new SimpleAssert<Boolean>(message) {
+    doAssert(new SimpleAssert<Boolean>(condition, Boolean.TRUE) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertTrue(condition, message);
       }
-
-      @Override
-      public Boolean getActual() {
-        return condition;
-      }
-
-      @Override
-      public Boolean getExpected() {
-        return Boolean.TRUE;
-      }
     });
   }
   
 	public void assertTrue(final boolean condition) {
-		doAssert(new SimpleAssert<Boolean>(null) {
+		doAssert(new SimpleAssert<Boolean>(condition, Boolean.TRUE) {
 			@Override
 			public void doAssert() {
 				org.testng.Assert.assertTrue(condition);
 			}
-
-			@Override
-			public Boolean getActual() {
-				return condition;
-			}
-
-			@Override
-			public Boolean getExpected() {
-				return Boolean.TRUE;
-			}
 		});
 	}
 
   public void assertFalse(final boolean condition, final String message) {
-    doAssert(new SimpleAssert<Boolean>(message) {
+    doAssert(new SimpleAssert<Boolean>(condition, Boolean.FALSE, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertFalse(condition, message);
       }
-
-      @Override
-      public Boolean getActual() {
-        return condition;
-      }
-
-      @Override
-      public Boolean getExpected() {
-        return Boolean.FALSE;
-      }
     });
   }
 
   public void assertFalse(final boolean condition) {
-    doAssert(new SimpleAssert<Boolean>(null) {
+    doAssert(new SimpleAssert<Boolean>(condition, Boolean.FALSE) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertFalse(condition);
       }
-
-      @Override
-      public Boolean getActual() {
-        return condition;
-      }
-
-      @Override
-      public Boolean getExpected() {
-        return Boolean.FALSE;
-      }
     });
   }
 
@@ -197,1109 +169,539 @@ public class Assertion implements IAssertLifecycle {
   }
 
   public <T> void assertEquals(final T actual, final T expected, final String message) {
-    doAssert(new SimpleAssert<T>(message) {
+    doAssert(new SimpleAssert<T>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public T getActual() {
-          return actual;
-      }
-
-      @Override
-      public T getExpected() {
-          return expected;
-      }
     });
   }
 
   public <T> void assertEquals(final T actual, final T expected) {
-    doAssert(new SimpleAssert<T>(null) {
+    doAssert(new SimpleAssert<T>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public T getActual() {
-          return actual;
-      }
-
-      @Override
-      public T getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final String actual, final String expected, final String message) {
-    doAssert(new SimpleAssert<String>(message) {
+    doAssert(new SimpleAssert<String>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public String getActual() {
-          return actual;
-      }
-
-      @Override
-      public String getExpected() {
-          return expected;
-      }
     });
   }
   public void assertEquals(final String actual, final String expected) {
-    doAssert(new SimpleAssert<String>(null) {
+    doAssert(new SimpleAssert<String>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public String getActual() {
-          return actual;
-      }
-
-      @Override
-      public String getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final double actual, final double expected, final double delta,
       final String message) {
-    doAssert(new SimpleAssert<Double>(message) {
+    doAssert(new SimpleAssert<Double>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, delta, message);
       }
-
-      @Override
-      public Double getActual() {
-          return actual;
-      }
-
-      @Override
-      public Double getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final double actual, final double expected, final double delta) {
-    doAssert(new SimpleAssert<Double>(null) {
+    doAssert(new SimpleAssert<Double>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, delta);
       }
-
-      @Override
-      public Double getActual() {
-          return actual;
-      }
-
-      @Override
-      public Double getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final float actual, final float expected, final float delta,
       final String message) {
-    doAssert(new SimpleAssert<Float>(message) {
+    doAssert(new SimpleAssert<Float>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, delta, message);
       }
-
-      @Override
-      public Float getActual() {
-          return actual;
-      }
-
-      @Override
-      public Float getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final float actual, final float expected, final float delta) {
-    doAssert(new SimpleAssert<Float>(null) {
+    doAssert(new SimpleAssert<Float>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, delta);
       }
-
-      @Override
-      public Float getActual() {
-          return actual;
-      }
-
-      @Override
-      public Float getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final long actual, final long expected, final String message) {
-    doAssert(new SimpleAssert<Long>(message) {
+    doAssert(new SimpleAssert<Long>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public Long getActual() {
-          return actual;
-      }
-
-      @Override
-      public Long getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final long actual, final long expected) {
-    doAssert(new SimpleAssert<Long>(null) {
+    doAssert(new SimpleAssert<Long>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public Long getActual() {
-          return actual;
-      }
-
-      @Override
-      public Long getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final boolean actual, final boolean expected, final String message) {
-    doAssert(new SimpleAssert<Boolean>(message) {
+    doAssert(new SimpleAssert<Boolean>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public Boolean getActual() {
-          return actual;
-      }
-
-      @Override
-      public Boolean getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final boolean actual, final boolean expected) {
-    doAssert(new SimpleAssert<Boolean>(null) {
+    doAssert(new SimpleAssert<Boolean>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public Boolean getActual() {
-          return actual;
-      }
-
-      @Override
-      public Boolean getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final byte actual, final byte expected, final String message) {
-    doAssert(new SimpleAssert<Byte>(message) {
+    doAssert(new SimpleAssert<Byte>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public Byte getActual() {
-          return actual;
-      }
-
-      @Override
-      public Byte getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final byte actual, final byte expected) {
-    doAssert(new SimpleAssert<Byte>(null) {
+    doAssert(new SimpleAssert<Byte>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public Byte getActual() {
-          return actual;
-      }
-
-      @Override
-      public Byte getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final char actual, final char expected, final String message) {
-    doAssert(new SimpleAssert<Character>(message) {
+    doAssert(new SimpleAssert<Character>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public Character getActual() {
-          return actual;
-      }
-
-      @Override
-      public Character getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final char actual, final char expected) {
-    doAssert(new SimpleAssert<Character>(null) {
+    doAssert(new SimpleAssert<Character>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public Character getActual() {
-          return actual;
-      }
-
-      @Override
-      public Character getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final short actual, final short expected, final String message) {
-    doAssert(new SimpleAssert<Short>(message) {
+    doAssert(new SimpleAssert<Short>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public Short getActual() {
-          return actual;
-      }
-
-      @Override
-      public Short getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final short actual, final short expected) {
-    doAssert(new SimpleAssert<Short>(null) {
+    doAssert(new SimpleAssert<Short>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public Short getActual() {
-          return actual;
-      }
-
-      @Override
-      public Short getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final int actual, final  int expected, final String message) {
-    doAssert(new SimpleAssert<Integer>(message) {
+    doAssert(new SimpleAssert<Integer>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public Integer getActual() {
-          return actual;
-      }
-
-      @Override
-      public Integer getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final int actual, final int expected) {
-    doAssert(new SimpleAssert<Integer>(null) {
+    doAssert(new SimpleAssert<Integer>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public Integer getActual() {
-          return actual;
-      }
-
-      @Override
-      public Integer getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertNotNull(final Object object) {
-    doAssert(new SimpleAssert<Object>(null) {
+    doAssert(new SimpleAssert<Object>(object, null) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotNull(object);
       }
-
-      @Override
-      public Object getActual() {
-        return object;
-      }
     });
   }
 
   public void assertNotNull(final Object object, final String message) {
-    doAssert(new SimpleAssert<Object>(message) {
+    doAssert(new SimpleAssert<Object>(object, null, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotNull(object, message);
       }
-
-      @Override
-      public Object getActual() {
-        return object;
-      }
     });
   }
 
   public void assertNull(final Object object) {
-    doAssert(new SimpleAssert<Object>(null) {
+    doAssert(new SimpleAssert<Object>(object, null) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNull(object);
       }
-
-      @Override
-      public Object getActual() {
-        return object;
-      }
     });
   }
 
   public void assertNull(final Object object, final String message) {
-    doAssert(new SimpleAssert<Object>(message) {
+    doAssert(new SimpleAssert<Object>(object, null, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNull(object, message);
       }
-
-      @Override
-      public Object getActual() {
-        return object;
-      }
     });
   }
 
   public void assertSame(final Object actual, final Object expected, final String message) {
-    doAssert(new SimpleAssert<Object>(message) {
+    doAssert(new SimpleAssert<Object>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertSame(actual, expected, message);
       }
-
-      @Override
-      public Object getActual() {
-          return actual;
-      }
-
-      @Override
-      public Object getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertSame(final Object actual, final Object expected) {
-    doAssert(new SimpleAssert<Object>(null) {
+    doAssert(new SimpleAssert<Object>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertSame(actual, expected);
       }
-
-      @Override
-      public Object getActual() {
-          return actual;
-      }
-
-      @Override
-      public Object getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertNotSame(final Object actual, final Object expected, final String message) {
-    doAssert(new SimpleAssert<Object>(message) {
+    doAssert(new SimpleAssert<Object>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotSame(actual, expected, message);
       }
-
-      @Override
-      public Object getActual() {
-          return actual;
-      }
-
-      @Override
-      public Object getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertNotSame(final Object actual, final Object expected) {
-    doAssert(new SimpleAssert<Object>(null) {
+    doAssert(new SimpleAssert<Object>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotSame(actual, expected);
       }
-
-      @Override
-      public Object getActual() {
-          return actual;
-      }
-
-      @Override
-      public Object getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final Collection<?> actual, final Collection<?> expected) {
-    doAssert(new SimpleAssert<Collection<?>>(null) {
+    doAssert(new SimpleAssert<Collection<?>>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public Collection<?> getActual() {
-          return actual;
-      }
-
-      @Override
-      public Collection<?> getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final Collection<?> actual, final Collection<?> expected,
       final String message) {
-    doAssert(new SimpleAssert<Collection<?>>(message) {
+    doAssert(new SimpleAssert<Collection<?>>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public Collection<?> getActual() {
-          return actual;
-      }
-
-      @Override
-      public Collection<?> getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final Object[] actual, final Object[] expected, final String message) {
-    doAssert(new SimpleAssert<Object[]>(message) {
+    doAssert(new SimpleAssert<Object[]>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public Object[] getActual() {
-          return actual;
-      }
-
-      @Override
-      public Object[] getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEqualsNoOrder(final Object[] actual, final Object[] expected,
       final String message) {
-    doAssert(new SimpleAssert<Object[]>(message) {
+    doAssert(new SimpleAssert<Object[]>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEqualsNoOrder(actual, expected, message);
       }
-
-      @Override
-      public Object[] getActual() {
-          return actual;
-      }
-
-      @Override
-      public Object[] getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final Object[] actual, final Object[] expected) {
-    doAssert(new SimpleAssert<Object[]>(null) {
+    doAssert(new SimpleAssert<Object[]>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public Object[] getActual() {
-          return actual;
-      }
-
-      @Override
-      public Object[] getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEqualsNoOrder(final Object[] actual, final Object[] expected) {
-    doAssert(new SimpleAssert<Object[]>(null) {
+    doAssert(new SimpleAssert<Object[]>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEqualsNoOrder(actual, expected);
       }
-
-      @Override
-      public Object[] getActual() {
-          return actual;
-      }
-
-      @Override
-      public Object[] getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final byte[] actual, final byte[] expected) {
-    doAssert(new SimpleAssert<byte[]>(null) {
+    doAssert(new SimpleAssert<byte[]>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public byte[] getActual() {
-          return actual;
-      }
-
-      @Override
-      public byte[] getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final byte[] actual, final byte[] expected,
       final String message) {
-    doAssert(new SimpleAssert<byte[]>(message) {
+    doAssert(new SimpleAssert<byte[]>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public byte[] getActual() {
-          return actual;
-      }
-
-      @Override
-      public byte[] getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final Set<?> actual, final Set<?> expected) {
-    doAssert(new SimpleAssert<Set<?>>(null) {
+    doAssert(new SimpleAssert<Set<?>>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public Set<?> getActual() {
-          return actual;
-      }
-
-      @Override
-      public Set<?> getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final Set<?> actual, final Set<?> expected, final String message) {
-    doAssert(new SimpleAssert<Set<?>>(message) {
+    doAssert(new SimpleAssert<Set<?>>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected, message);
       }
-
-      @Override
-      public Set<?> getActual() {
-          return actual;
-      }
-
-      @Override
-      public Set<?> getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertEquals(final Map<?, ?> actual, final Map<?, ?> expected) {
-    doAssert(new SimpleAssert<Map<?, ?>>(null) {
+    doAssert(new SimpleAssert<Map<?, ?>>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertEquals(actual, expected);
       }
-
-      @Override
-      public Map<?, ?> getActual() {
-          return actual;
-      }
-
-      @Override
-      public Map<?, ?> getExpected() {
-          return expected;
-      }
     });
   }
 
   public  void assertNotEquals(final Object actual, final Object expected, final String message) {
-    doAssert(new SimpleAssert<Object>(message) {
+    doAssert(new SimpleAssert<Object>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, message);
       }
-
-      @Override
-      public Object getActual() {
-          return actual;
-      }
-
-      @Override
-      public Object getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertNotEquals(final Object actual, final Object expected) {
-    doAssert(new SimpleAssert<Object>(null) {
+    doAssert(new SimpleAssert<Object>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected);
       }
-
-      @Override
-      public Object getActual() {
-          return actual;
-      }
-
-      @Override
-      public Object getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final String actual, final String expected, final String message) {
-    doAssert(new SimpleAssert<String>(message) {
+    doAssert(new SimpleAssert<String>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, message);
       }
-
-      @Override
-      public String getActual() {
-          return actual;
-      }
-
-      @Override
-      public String getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final String actual, final String expected) {
-    doAssert(new SimpleAssert<String>(null) {
+    doAssert(new SimpleAssert<String>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected);
       }
-
-      @Override
-      public String getActual() {
-          return actual;
-      }
-
-      @Override
-      public String getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final long actual, final long expected, final String message) {
-    doAssert(new SimpleAssert<Long>(message) {
+    doAssert(new SimpleAssert<Long>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, message);
       }
-
-      @Override
-      public Long getActual() {
-          return actual;
-      }
-
-      @Override
-      public Long getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final long actual, final long expected) {
-    doAssert(new SimpleAssert<Long>(null) {
+    doAssert(new SimpleAssert<Long>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected);
       }
-
-      @Override
-      public Long getActual() {
-          return actual;
-      }
-
-      @Override
-      public Long getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final boolean actual, final boolean expected, final String message) {
-    doAssert(new SimpleAssert<Boolean>(message) {
+    doAssert(new SimpleAssert<Boolean>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, message);
       }
-
-      @Override
-      public Boolean getActual() {
-          return actual;
-      }
-
-      @Override
-      public Boolean getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final boolean actual, final boolean expected) {
-    doAssert(new SimpleAssert<Boolean>(null) {
+    doAssert(new SimpleAssert<Boolean>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected);
       }
-
-      @Override
-      public Boolean getActual() {
-          return actual;
-      }
-
-      @Override
-      public Boolean getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final byte actual, final byte expected, final String message) {
-    doAssert(new SimpleAssert<Byte>(message) {
+    doAssert(new SimpleAssert<Byte>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, message);
       }
-
-      @Override
-      public Byte getActual() {
-          return actual;
-      }
-
-      @Override
-      public Byte getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final byte actual, final byte expected) {
-    doAssert(new SimpleAssert<Byte>(null) {
+    doAssert(new SimpleAssert<Byte>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected);
       }
-
-      @Override
-      public Byte getActual() {
-          return actual;
-      }
-
-      @Override
-      public Byte getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final char actual, final char expected, final String message) {
-    doAssert(new SimpleAssert<Character>(message) {
+    doAssert(new SimpleAssert<Character>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, message);
       }
-
-      @Override
-      public Character getActual() {
-          return actual;
-      }
-
-      @Override
-      public Character getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final char actual, final char expected) {
-    doAssert(new SimpleAssert<Character>(null) {
+    doAssert(new SimpleAssert<Character>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected);
       }
-
-      @Override
-      public Character getActual() {
-          return actual;
-      }
-
-      @Override
-      public Character getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final short actual, final short expected, final String message) {
-    doAssert(new SimpleAssert<Short>(message) {
+    doAssert(new SimpleAssert<Short>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, message);
       }
-
-      @Override
-      public Short getActual() {
-          return actual;
-      }
-
-      @Override
-      public Short getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final short actual, final short expected) {
-    doAssert(new SimpleAssert<Short>(null) {
+    doAssert(new SimpleAssert<Short>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected);
       }
-
-      @Override
-      public Short getActual() {
-          return actual;
-      }
-
-      @Override
-      public Short getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final int actual, final int expected, final String message) {
-    doAssert(new SimpleAssert<Integer>(message) {
+    doAssert(new SimpleAssert<Integer>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, message);
       }
-
-      @Override
-      public Integer getActual() {
-          return actual;
-      }
-
-      @Override
-      public Integer getExpected() {
-          return expected;
-      }
     });
   }
 
   void assertNotEquals(final int actual, final int expected) {
-    doAssert(new SimpleAssert<Integer>(null) {
+    doAssert(new SimpleAssert<Integer>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected);
       }
-
-      @Override
-      public Integer getActual() {
-          return actual;
-      }
-
-      @Override
-      public Integer getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertNotEquals(final float actual, final float expected, final float delta,
       final String message) {
-    doAssert(new SimpleAssert<Float>(message) {
+    doAssert(new SimpleAssert<Float>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, delta, message);
       }
-
-      @Override
-      public Float getActual() {
-          return actual;
-      }
-
-      @Override
-      public Float getExpected() {
-          return expected;
-      }
    });
   }
 
   public void assertNotEquals(final float actual, final float expected, final float delta) {
-    doAssert(new SimpleAssert<Float>(null) {
+    doAssert(new SimpleAssert<Float>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, delta);
       }
-
-      @Override
-      public Float getActual() {
-          return actual;
-      }
-
-      @Override
-      public Float getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertNotEquals(final double actual, final double expected, final double delta,
       final String message) {
-    doAssert(new SimpleAssert<Double>(message) {
+    doAssert(new SimpleAssert<Double>(actual, expected, message) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, delta, message);
       }
-
-      @Override
-      public Double getActual() {
-          return actual;
-      }
-
-      @Override
-      public Double getExpected() {
-          return expected;
-      }
     });
   }
 
   public void assertNotEquals(final double actual, final double expected, final double delta) {
-    doAssert(new SimpleAssert<Double>(null) {
+    doAssert(new SimpleAssert<Double>(actual, expected) {
       @Override
       public void doAssert() {
         org.testng.Assert.assertNotEquals(actual, expected, delta);
       }
-
-      @Override
-      public Double getActual() {
-          return actual;
-      }
-
-      @Override
-      public Double getExpected() {
-          return expected;
-      }
     });
   }
 

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-java/testng.git



More information about the pkg-java-commits mailing list