Fix parameter order for assertEquals(expected, actual)

h2/src/test/org/h2/test/TestBase.java

@@ -8,6 +8,8 @@ package org.h2.test;
 
 import java.io.File;
 import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
 import java.io.PrintWriter;
 import java.io.Reader;
 import java.sql.Connection;
@@ -504,7 +506,7 @@ public abstract class TestBase {
      * @throws AssertionError if the values are not equal
      */
     protected void assertEquals(byte[] expected, byte[] actual) {
-        assertEquals("length", expected.length, actual.length);
+        assertEquals(expected.length, actual.length);
         for (int i = 0; i < expected.length; i++) {
             if (expected[i] != actual[i]) {
                 fail("[" + i + "]: expected: " + (int) expected[i] + " actual: " + (int) actual[i]);
@@ -512,6 +514,57 @@ public abstract class TestBase {
         }
     }
 
+    /**
+     * Check if two readers are equal, and if not throw an exception.
+     *
+     * @param expected the expected value
+     * @param actual the actual value
+     * @throws AssertionError if the values are not equal
+     */
+    protected void assertEqualReaders(Reader expected, Reader actual, int len) throws IOException {
+        for (int i = 0; len < 0 || i < len; i++) {
+            int ce = expected.read();
+            int ca = actual.read();
+            assertEquals(ce, ca);
+            if (ce == -1) {
+                break;
+            }
+        }
+        expected.close();
+        actual.close();
+    }
+
+    /**
+     * Check if two streams are equal, and if not throw an exception.
+     *
+     * @param expected the expected value
+     * @param actual the actual value
+     * @throws AssertionError if the values are not equal
+     */
+    protected void assertEqualStreams(InputStream expected, InputStream actual, int len) throws IOException {
+        // this doesn't actually read anything - just tests reading 0 bytes
+        actual.read(new byte[0]);
+        expected.read(new byte[0]);
+        actual.read(new byte[10], 3, 0);
+        expected.read(new byte[10], 0, 0);
+
+        for (int i = 0; len < 0 || i < len; i++) {
+            int ca = actual.read();
+            actual.read(new byte[0]);
+            int ce = expected.read();
+            assertEquals(ce, ca);
+            if (ca == -1) {
+                break;
+            }
+        }
+        actual.read(new byte[10], 3, 0);
+        expected.read(new byte[10], 0, 0);
+        actual.read(new byte[0]);
+        expected.read(new byte[0]);
+        actual.close();
+        expected.close();
+    }
+
     /**
      * Check if two values are equal, and if not throw an exception.
      *
@@ -703,7 +756,7 @@ public abstract class TestBase {
         while (rs.next()) {
             i++;
         }
-        assertEquals(i, expected);
+        assertEquals(expected, i);
     }
 
     /**
@@ -724,12 +777,12 @@ public abstract class TestBase {
     /**
      * Check that the result set of a query is exactly this value.
      *
+     * @param expected the expected result value
      * @param stat the statement
      * @param sql the SQL statement to execute
-     * @param expected the expected result value
      * @throws AssertionError if a different result value was returned
      */
-    protected void assertResult(Statement stat, String sql, String expected) throws SQLException {
+    protected void assertResult(String expected, Statement stat, String sql) throws SQLException {
         ResultSet rs = stat.executeQuery(sql);
         if (rs.next()) {
             String actual = rs.getString(1);
@@ -773,24 +826,24 @@ public abstract class TestBase {
                 String className = meta.getColumnClassName(i + 1);
                 switch (t) {
                 case Types.INTEGER:
-                    assertEquals(typeName, "INTEGER");
-                    assertEquals(className, "java.lang.Integer");
+                    assertEquals("INTEGER", typeName);
+                    assertEquals("java.lang.Integer", className);
                     break;
                 case Types.VARCHAR:
-                    assertEquals(typeName, "VARCHAR");
-                    assertEquals(className, "java.lang.String");
+                    assertEquals("VARCHAR", typeName);
+                    assertEquals("java.lang.String", className);
                     break;
                 case Types.SMALLINT:
-                    assertEquals(typeName, "SMALLINT");
-                    assertEquals(className, "java.lang.Short");
+                    assertEquals("SMALLINT", typeName);
+                    assertEquals("java.lang.Short", className);
                     break;
                 case Types.TIMESTAMP:
-                    assertEquals(typeName, "TIMESTAMP");
-                    assertEquals(className, "java.sql.Timestamp");
+                    assertEquals("TIMESTAMP", typeName);
+                    assertEquals("java.sql.Timestamp", className);
                     break;
                 case Types.DECIMAL:
-                    assertEquals(typeName, "DECIMAL");
-                    assertEquals(className, "java.math.BigDecimal");
+                    assertEquals("DECIMAL", typeName);
+                    assertEquals("java.math.BigDecimal", className);
                     break;
                 default:
                 }
@@ -1034,7 +1087,7 @@ public abstract class TestBase {
                 fail("only found in first: " + s);
             }
         }
-        assertEquals(list2.size(), 0);
+        assertEquals(0, list2.size());
         assertFalse(rs2.next());
     }
 

h2/src/test/org/h2/test/db/TestAutoRecompile.java

@@ -33,12 +33,12 @@ public class TestAutoRecompile extends TestBase {
         Statement stat = conn.createStatement();
         stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY)");
         PreparedStatement prep = conn.prepareStatement("SELECT * FROM TEST");
-        assertEquals(prep.executeQuery().getMetaData().getColumnCount(), 1);
+        assertEquals(1, prep.executeQuery().getMetaData().getColumnCount());
         stat.execute("ALTER TABLE TEST ADD COLUMN NAME VARCHAR(255)");
-        assertEquals(prep.executeQuery().getMetaData().getColumnCount(), 2);
+        assertEquals(2, prep.executeQuery().getMetaData().getColumnCount());
         stat.execute("DROP TABLE TEST");
         stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, X INT, Y INT)");
-        assertEquals(prep.executeQuery().getMetaData().getColumnCount(), 3);
+        assertEquals(3, prep.executeQuery().getMetaData().getColumnCount());
         // TODO test auto-recompile with insert..select, views and so on
 
         prep = conn.prepareStatement("INSERT INTO TEST VALUES(1, 2, 3)");

h2/src/test/org/h2/test/db/TestCases.java

@@ -412,7 +412,7 @@ public class TestCases extends TestBase {
         conn = getConnection("cases");
         ResultSet rs = conn.createStatement().executeQuery("SELECT * FROM TEST");
         rs.next();
-        assertEquals(rs.getString(1), "1");
+        assertEquals("1", rs.getString(1));
         assertFalse(rs.next());
         stat = conn.createStatement();
         stat.execute("drop table test");
@@ -424,7 +424,7 @@ public class TestCases extends TestBase {
         stat = conn.createStatement();
         rs = conn.createStatement().executeQuery("SELECT * FROM TEST");
         rs.next();
-        assertEquals(rs.getString(1), "1");
+        assertEquals("1", rs.getString(1));
         assertFalse(rs.next());
         stat.execute("drop table test");
         stat.execute("create table test(id identity)");
@@ -439,7 +439,7 @@ public class TestCases extends TestBase {
         conn = getConnection("cases");
         rs = conn.createStatement().executeQuery("SELECT * FROM TEST");
         rs.next();
-        assertEquals(rs.getString(1), "1");
+        assertEquals("1", rs.getString(1));
         assertFalse(rs.next());
         conn.close();
     }
@@ -455,18 +455,18 @@ public class TestCases extends TestBase {
         ResultSet rs;
         rs = stat.executeQuery("select name from test order by name");
         rs.next();
-        assertEquals(rs.getString(1), "Hello");
+        assertEquals("Hello", rs.getString(1));
         rs.next();
-        assertEquals(rs.getString(1), "HELLO");
+        assertEquals("HELLO", rs.getString(1));
         rs.next();
-        assertEquals(rs.getString(1), "World");
+        assertEquals("World", rs.getString(1));
         rs.next();
-        assertEquals(rs.getString(1), "WORLD");
+        assertEquals("WORLD", rs.getString(1));
         rs = stat.executeQuery("select name from test where name like 'He%'");
         rs.next();
-        assertEquals(rs.getString(1), "Hello");
+        assertEquals("Hello", rs.getString(1));
         rs.next();
-        assertEquals(rs.getString(1), "HELLO");
+        assertEquals("HELLO", rs.getString(1));
         conn.close();
     }
 
@@ -555,7 +555,7 @@ public class TestCases extends TestBase {
         stat.execute("insert into test(name) values('test')");
         ResultSet rs = stat.executeQuery("select * from test");
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
         assertFalse(rs.next());
         conn.close();
     }
@@ -596,17 +596,17 @@ public class TestCases extends TestBase {
         prep.execute();
         ResultSet rs = stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
         rs.next();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), big);
-        assertEquals(readString(rs.getCharacterStream(2)), big);
-        assertEquals(rs.getString(3), big);
-        assertEquals(readString(rs.getCharacterStream(3)), big);
+        assertEquals(1, rs.getInt(1));
+        assertEquals(big, rs.getString(2));
+        assertEquals(big, readString(rs.getCharacterStream(2)));
+        assertEquals(big, rs.getString(3));
+        assertEquals(big, readString(rs.getCharacterStream(3)));
         rs.next();
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getString(2), big);
-        assertEquals(readString(rs.getCharacterStream(2)), big);
-        assertEquals(rs.getString(3), big);
-        assertEquals(readString(rs.getCharacterStream(3)), big);
+        assertEquals(2, rs.getInt(1));
+        assertEquals(big, rs.getString(2));
+        assertEquals(big, readString(rs.getCharacterStream(2)));
+        assertEquals(big, rs.getString(3));
+        assertEquals(big, readString(rs.getCharacterStream(3)));
         rs.next();
         assertFalse(rs.next());
         conn.close();
@@ -779,9 +779,9 @@ public class TestCases extends TestBase {
         deleteDb("cases");
         Connection conn = getConnection("cases");
         Statement stat = conn.createStatement();
-        stat.execute("create table employee(id int, " + "firstName VARCHAR(50), " + "salary decimal(10, 2), "
-                + "superior_id int, " + "CONSTRAINT PK_employee PRIMARY KEY (id), "
-                + "CONSTRAINT FK_superior FOREIGN KEY (superior_id) " + "REFERENCES employee(ID))");
+        stat.execute("create table employee(id int, firstName VARCHAR(50), salary decimal(10, 2), "
+                + "superior_id int, CONSTRAINT PK_employee PRIMARY KEY (id), "
+                + "CONSTRAINT FK_superior FOREIGN KEY (superior_id) REFERENCES employee(ID))");
         stat.execute("DROP TABLE employee");
         conn.close();
         conn = getConnection("cases");
@@ -794,17 +794,17 @@ public class TestCases extends TestBase {
 
         Connection c0 = getConnection("cases");
         c0.createStatement().executeUpdate("SET AUTOCOMMIT FALSE");
-        c0
-                .createStatement()
-                .executeUpdate(
-                        "create table australia (ID  INTEGER NOT NULL, Name VARCHAR(100), firstName VARCHAR(100), Points INTEGER, LicenseID INTEGER, PRIMARY KEY(ID))");
+        c0.createStatement().executeUpdate(
+                "create table australia (ID  INTEGER NOT NULL, " +
+                "Name VARCHAR(100), firstName VARCHAR(100), " +
+                "Points INTEGER, LicenseID INTEGER, PRIMARY KEY(ID))");
         c0.createStatement().executeUpdate("COMMIT");
         c0.close();
 
         c0 = getConnection("cases");
         c0.createStatement().executeUpdate("SET AUTOCOMMIT FALSE");
-        PreparedStatement p15 = c0
-                .prepareStatement("insert into australia (id,Name,firstName,Points,LicenseID) values (?,?,?,?,?)");
+        PreparedStatement p15 = c0.prepareStatement("insert into australia"
+                + "(id, Name, firstName, Points, LicenseID) values (?, ?, ?, ?, ?)");
         int len = getSize(1, 1000);
         for (int i = 0; i < len; i++) {
             p15.setInt(1, i);
@@ -833,17 +833,16 @@ public class TestCases extends TestBase {
         c0 = getConnection("cases");
         c0.createStatement().executeUpdate("SET AUTOCOMMIT FALSE");
         c0.createStatement().executeUpdate("drop table australia");
-        c0
-                .createStatement()
-                .executeUpdate(
-                        "create table australia (ID  INTEGER NOT NULL, Name VARCHAR(100), firstName VARCHAR(100), Points INTEGER, LicenseID INTEGER, PRIMARY KEY(ID))");
+        c0.createStatement().executeUpdate(
+                "create table australia (ID  INTEGER NOT NULL, Name VARCHAR(100), "
+                        + "firstName VARCHAR(100), Points INTEGER, LicenseID INTEGER, PRIMARY KEY(ID))");
         c0.createStatement().executeUpdate("COMMIT");
         c0.close();
 
         c0 = getConnection("cases");
         c0.createStatement().executeUpdate("SET AUTOCOMMIT FALSE");
-        PreparedStatement p65 = c0
-                .prepareStatement("insert into australia (id,Name,FirstName,Points,LicenseID) values (?,?,?,?,?)");
+        PreparedStatement p65 = c0.prepareStatement("insert into australia"
+                + "(id, Name, FirstName, Points, LicenseID) values (?, ?, ?, ?, ?)");
         len = getSize(1, 1000);
         for (int i = 0; i < len; i++) {
             p65.setInt(1, i);

h2/src/test/org/h2/test/db/TestCluster.java

@@ -146,7 +146,7 @@ public class TestCluster extends TestBase {
             prep.setInt(1, i);
             ResultSet rs = prep.executeQuery();
             rs.next();
-            assertEquals(rs.getString(2), "Data" + i);
+            assertEquals("Data" + i, rs.getString(2));
             assertFalse(rs.next());
         }
     }

h2/src/test/org/h2/test/db/TestCompatibility.java

@@ -155,10 +155,10 @@ public class TestCompatibility extends TestBase {
         stat.execute("CREATE TABLE TEST(ID INT, NAME VARCHAR)");
         stat.execute("INSERT INTO TEST VALUES(1, 'Hello'), (2, 'World')");
         org.h2.mode.FunctionsMySQL.register(conn);
-        assertResult(stat, "SELECT UNIX_TIMESTAMP('2007-11-30 10:30:19Z')", "1196418619");
-        assertResult(stat, "SELECT UNIX_TIMESTAMP(FROM_UNIXTIME(1196418619))", "1196418619");
-        assertResult(stat, "SELECT FROM_UNIXTIME(1196300000, '%Y %M')", "2007 November");
-        assertResult(stat, "SELECT DATE('2003-12-31 11:02:03')", "2003-12-31");
+        assertResult("1196418619", stat, "SELECT UNIX_TIMESTAMP('2007-11-30 10:30:19Z')");
+        assertResult("1196418619", stat, "SELECT UNIX_TIMESTAMP(FROM_UNIXTIME(1196418619))");
+        assertResult("2007 November", stat, "SELECT FROM_UNIXTIME(1196300000, '%Y %M')");
+        assertResult("2003-12-31", stat, "SELECT DATE('2003-12-31 11:02:03')");
 
     }
 

h2/src/test/org/h2/test/db/TestExclusive.java

@@ -66,7 +66,7 @@ public class TestExclusive extends TestBase {
                 break;
             }
         }
-        assertEquals(state[0], 2);
+        assertEquals(2, state[0]);
         stat.execute("set exclusive true");
         conn.close();
 

h2/src/test/org/h2/test/db/TestFullText.java

@@ -155,28 +155,28 @@ public class TestFullText extends TestBase {
         ResultSet rs;
         rs = stat.executeQuery("SELECT * FROM " + prefix + "SEARCH('Hello', 0, 0)");
         rs.next();
-        assertEquals(rs.getString(1), "\"PUBLIC\".\"TEST\" WHERE \"ID\"=1");
+        assertEquals("\"PUBLIC\".\"TEST\" WHERE \"ID\"=1", rs.getString(1));
         assertFalse(rs.next());
         rs = stat.executeQuery("SELECT * FROM " + prefix + "SEARCH('Hallo', 0, 0)");
         assertFalse(rs.next());
         stat.execute("INSERT INTO TEST VALUES(2, 'Hallo Welt')");
         rs = stat.executeQuery("SELECT * FROM " + prefix + "SEARCH('Hello', 0, 0)");
         rs.next();
-        assertEquals(rs.getString(1), "\"PUBLIC\".\"TEST\" WHERE \"ID\"=1");
+        assertEquals("\"PUBLIC\".\"TEST\" WHERE \"ID\"=1", rs.getString(1));
         assertFalse(rs.next());
         rs = stat.executeQuery("SELECT * FROM " + prefix + "SEARCH('Hallo', 0, 0)");
         rs.next();
-        assertEquals(rs.getString(1), "\"PUBLIC\".\"TEST\" WHERE \"ID\"=2");
+        assertEquals("\"PUBLIC\".\"TEST\" WHERE \"ID\"=2", rs.getString(1));
         assertFalse(rs.next());
 
         stat.execute("CALL " + prefix + "REINDEX()");
         rs = stat.executeQuery("SELECT * FROM " + prefix + "SEARCH('Hello', 0, 0)");
         rs.next();
-        assertEquals(rs.getString(1), "\"PUBLIC\".\"TEST\" WHERE \"ID\"=1");
+        assertEquals("\"PUBLIC\".\"TEST\" WHERE \"ID\"=1", rs.getString(1));
         assertFalse(rs.next());
         rs = stat.executeQuery("SELECT * FROM " + prefix + "SEARCH('Hallo', 0, 0)");
         rs.next();
-        assertEquals(rs.getString(1), "\"PUBLIC\".\"TEST\" WHERE \"ID\"=2");
+        assertEquals("\"PUBLIC\".\"TEST\" WHERE \"ID\"=2", rs.getString(1));
         assertFalse(rs.next());
 
         stat.execute("INSERT INTO TEST VALUES(3, 'Hello World')");
@@ -185,13 +185,13 @@ public class TestFullText extends TestBase {
 
         rs = stat.executeQuery("SELECT * FROM " + prefix + "SEARCH('World', 0, 0) ORDER BY QUERY");
         rs.next();
-        assertEquals(rs.getString(1), "\"PUBLIC\".\"TEST\" WHERE \"ID\"=1");
+        assertEquals("\"PUBLIC\".\"TEST\" WHERE \"ID\"=1", rs.getString(1));
         rs.next();
-        assertEquals(rs.getString(1), "\"PUBLIC\".\"TEST\" WHERE \"ID\"=3");
+        assertEquals("\"PUBLIC\".\"TEST\" WHERE \"ID\"=3", rs.getString(1));
         rs.next();
-        assertEquals(rs.getString(1), "\"PUBLIC\".\"TEST\" WHERE \"ID\"=4");
+        assertEquals("\"PUBLIC\".\"TEST\" WHERE \"ID\"=4", rs.getString(1));
         rs.next();
-        assertEquals(rs.getString(1), "\"PUBLIC\".\"TEST\" WHERE \"ID\"=5");
+        assertEquals("\"PUBLIC\".\"TEST\" WHERE \"ID\"=5", rs.getString(1));
         assertFalse(rs.next());
 
         rs = stat.executeQuery("SELECT * FROM " + prefix + "SEARCH('World', 1, 0)");
@@ -215,7 +215,7 @@ public class TestFullText extends TestBase {
 
         rs = stat.executeQuery("SELECT * FROM " + prefix + "SEARCH('1', 0, 0)");
         rs.next();
-        assertEquals(rs.getString(1), "\"PUBLIC\".\"TEST\" WHERE \"ID\"=1");
+        assertEquals("\"PUBLIC\".\"TEST\" WHERE \"ID\"=1", rs.getString(1));
         assertFalse(rs.next());
         conn.close();
 

h2/src/test/org/h2/test/db/TestFunctions.java

@@ -291,45 +291,45 @@ public class TestFunctions extends TestBase implements AggregateFunction {
         deleteDb("functions");
         Connection conn = getConnection("functions");
         Statement stat = conn.createStatement();
-        test(stat, "abs(null)", null);
-        test(stat, "abs(1)", "1");
-        test(stat, "abs(1)", "1");
+        assertCallResult(null, stat, "abs(null)");
+        assertCallResult("1", stat, "abs(1)");
+        assertCallResult("1", stat, "abs(1)");
 
         stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR)");
         stat.execute("CREATE ALIAS ADD_ROW FOR \"" + getClass().getName() + ".addRow\"");
         ResultSet rs;
         rs = stat.executeQuery("CALL ADD_ROW(1, 'Hello')");
         rs.next();
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         rs = stat.executeQuery("SELECT * FROM TEST");
         rs.next();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(1, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         assertFalse(rs.next());
 
         rs = stat.executeQuery("CALL ADD_ROW(2, 'World')");
 
         stat.execute("CREATE ALIAS SELECT_F FOR \"" + getClass().getName() + ".select\"");
         rs = stat.executeQuery("CALL SELECT_F('SELECT * FROM TEST ORDER BY ID')");
-        assertEquals(rs.getMetaData().getColumnCount(), 2);
+        assertEquals(2, rs.getMetaData().getColumnCount());
         rs.next();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(1, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         rs.next();
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getString(2), "World");
+        assertEquals(2, rs.getInt(1));
+        assertEquals("World", rs.getString(2));
         assertFalse(rs.next());
 
         rs = stat.executeQuery("SELECT NAME FROM SELECT_F('SELECT * FROM TEST ORDER BY NAME') ORDER BY NAME DESC");
-        assertEquals(rs.getMetaData().getColumnCount(), 1);
+        assertEquals(1, rs.getMetaData().getColumnCount());
         rs.next();
-        assertEquals(rs.getString(1), "World");
+        assertEquals("World", rs.getString(1));
         rs.next();
-        assertEquals(rs.getString(1), "Hello");
+        assertEquals("Hello", rs.getString(1));
         assertFalse(rs.next());
 
         rs = stat.executeQuery("SELECT SELECT_F('SELECT * FROM TEST WHERE ID=' || ID) FROM TEST ORDER BY ID");
-        assertEquals(rs.getMetaData().getColumnCount(), 1);
+        assertEquals(1, rs.getMetaData().getColumnCount());
         rs.next();
         assertEquals("((1, Hello))", rs.getString(1));
         rs.next();
@@ -337,7 +337,7 @@ public class TestFunctions extends TestBase implements AggregateFunction {
         assertFalse(rs.next());
 
         rs = stat.executeQuery("SELECT SELECT_F('SELECT * FROM TEST ORDER BY ID') FROM DUAL");
-        assertEquals(rs.getMetaData().getColumnCount(), 1);
+        assertEquals(1, rs.getMetaData().getColumnCount());
         rs.next();
         assertEquals("((1, Hello), (2, World))", rs.getString(1));
         assertFalse(rs.next());
@@ -351,50 +351,50 @@ public class TestFunctions extends TestBase implements AggregateFunction {
 
         stat.execute("CREATE ALIAS SIMPLE FOR \"" + getClass().getName() + ".simpleResultSet\"");
         rs = stat.executeQuery("CALL SIMPLE(2, 1,1,1,1,1,1,1)");
-        assertEquals(rs.getMetaData().getColumnCount(), 2);
+        assertEquals(2, rs.getMetaData().getColumnCount());
         rs.next();
-        assertEquals(rs.getInt(1), 0);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(0, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         rs.next();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), "World");
+        assertEquals(1, rs.getInt(1));
+        assertEquals("World", rs.getString(2));
         assertFalse(rs.next());
 
         rs = stat.executeQuery("SELECT * FROM SIMPLE(1, 1,1,1,1,1,1,1)");
-        assertEquals(rs.getMetaData().getColumnCount(), 2);
+        assertEquals(2, rs.getMetaData().getColumnCount());
         rs.next();
-        assertEquals(rs.getInt(1), 0);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(0, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         assertFalse(rs.next());
 
         stat.execute("CREATE ALIAS ARRAY FOR \"" + getClass().getName() + ".getArray\"");
         rs = stat.executeQuery("CALL ARRAY()");
-        assertEquals(rs.getMetaData().getColumnCount(), 2);
+        assertEquals(2, rs.getMetaData().getColumnCount());
         rs.next();
-        assertEquals(rs.getInt(1), 0);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(0, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         assertFalse(rs.next());
 
         stat.execute("CREATE ALIAS ROOT FOR \"" + getClass().getName() + ".root\"");
         rs = stat.executeQuery("CALL ROOT(9)");
         rs.next();
-        assertEquals(rs.getInt(1), 3);
+        assertEquals(3, rs.getInt(1));
         assertFalse(rs.next());
 
         stat.execute("CREATE ALIAS MAX_ID FOR \"" + getClass().getName() + ".selectMaxId\"");
         rs = stat.executeQuery("CALL MAX_ID()");
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
         assertFalse(rs.next());
 
         rs = stat.executeQuery("SELECT * FROM MAX_ID()");
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
         assertFalse(rs.next());
 
         rs = stat.executeQuery("CALL CASE WHEN -9 < 0 THEN 0 ELSE ROOT(-9) END");
         rs.next();
-        assertEquals(rs.getInt(1), 0);
+        assertEquals(0, rs.getInt(1));
         assertFalse(rs.next());
 
         stat.execute("CREATE ALIAS blob2stream FOR \"" + getClass().getName() + ".blob2stream\"");
@@ -414,19 +414,19 @@ public class TestFunctions extends TestBase implements AggregateFunction {
 
         stat.execute("CREATE ALIAS NULL_RESULT FOR \"" + getClass().getName() + ".nullResultSet\"");
         rs = stat.executeQuery("CALL NULL_RESULT()");
-        assertEquals(rs.getMetaData().getColumnCount(), 1);
+        assertEquals(1, rs.getMetaData().getColumnCount());
         rs.next();
-        assertEquals(rs.getString(1), null);
+        assertEquals(null, rs.getString(1));
         assertFalse(rs.next());
 
         conn.close();
     }
 
-    private void test(Statement stat, String sql, String value) throws SQLException {
+    private void assertCallResult(String expected, Statement stat, String sql) throws SQLException {
         ResultSet rs = stat.executeQuery("CALL " + sql);
         rs.next();
         String s = rs.getString(1);
-        assertEquals(value, s);
+        assertEquals(expected, s);
     }
 
     /**

h2/src/test/org/h2/test/db/TestLinkedTable.java

@@ -204,10 +204,10 @@ public class TestLinkedTable extends TestBase {
         stat2.execute("CREATE LINKED TABLE two('org.h2.Driver', 'jdbc:h2:mem:one', 'sa', 'sa', 'PUBLIC.A');");
         ResultSet rs = stat2.executeQuery("SELECT * FROM one");
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
         rs = stat2.executeQuery("SELECT * FROM two");
         rs.next();
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         conn.close();
         conn2.close();
     }
@@ -270,29 +270,29 @@ public class TestLinkedTable extends TestBase {
 
         rs = stat2.executeQuery("SELECT * FROM TEST_LINK_DI ORDER BY ID");
         rs.next();
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getString(2), "Hello2");
+        assertEquals(2, rs.getInt(1));
+        assertEquals("Hello2", rs.getString(2));
         rs.next();
-        assertEquals(rs.getInt(1), 3);
-        assertEquals(rs.getString(2), "World3");
+        assertEquals(3, rs.getInt(1));
+        assertEquals("World3", rs.getString(2));
         assertFalse(rs.next());
 
         rs = stat2.executeQuery("SELECT * FROM TEST_LINK_U ORDER BY ID");
         rs.next();
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getString(2), "Hello2");
+        assertEquals(2, rs.getInt(1));
+        assertEquals("Hello2", rs.getString(2));
         rs.next();
-        assertEquals(rs.getInt(1), 3);
-        assertEquals(rs.getString(2), "World3");
+        assertEquals(3, rs.getInt(1));
+        assertEquals("World3", rs.getString(2));
         assertFalse(rs.next());
 
         rs = stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
         rs.next();
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getString(2), "Hello2");
+        assertEquals(2, rs.getInt(1));
+        assertEquals("Hello2", rs.getString(2));
         rs.next();
-        assertEquals(rs.getInt(1), 3);
-        assertEquals(rs.getString(2), "World3");
+        assertEquals(3, rs.getInt(1));
+        assertEquals("World3", rs.getString(2));
         assertFalse(rs.next());
 
         conn.close();
@@ -385,22 +385,22 @@ public class TestLinkedTable extends TestBase {
 
         rs = stat.executeQuery("SELECT COUNT(*) FROM LINK_TEST");
         rs.next();
-        assertEquals(rs.getInt(1), 4);
+        assertEquals(4, rs.getInt(1));
 
         rs = stat.executeQuery("SELECT COUNT(*) FROM LINK_TEST WHERE NAME='Link Test'");
         rs.next();
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
 
         int uc = stat.executeUpdate("DELETE FROM LINK_TEST WHERE ID=3");
-        assertEquals(uc, 1);
+        assertEquals(1, uc);
 
         rs = stat.executeQuery("SELECT COUNT(*) FROM LINK_TEST");
         rs.next();
-        assertEquals(rs.getInt(1), 3);
+        assertEquals(3, rs.getInt(1));
 
         rs = stat.executeQuery("SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME='LINK_TEST'");
         rs.next();
-        assertEquals(rs.getString("TABLE_TYPE"), "TABLE LINK");
+        assertEquals("TABLE LINK", rs.getString("TABLE_TYPE"));
 
         rs.next();
         rs = stat.executeQuery("SELECT * FROM LINK_TEST WHERE ID=0");
@@ -427,7 +427,7 @@ public class TestLinkedTable extends TestBase {
                 + "', 'sa1', 'abc abc', '(SELECT COUNT(*) FROM TEST)')");
         rs = stat.executeQuery("SELECT * FROM LINK_TEST");
         rs.next();
-        assertEquals(rs.getInt(1), 3);
+        assertEquals(3, rs.getInt(1));
         assertFalse(rs.next());
 
         conn.close();
@@ -439,23 +439,23 @@ public class TestLinkedTable extends TestBase {
     private void testRow(Statement stat, String name) throws SQLException {
         ResultSet rs = stat.executeQuery("SELECT * FROM " + name + " WHERE ID=1");
         rs.next();
-        assertEquals(rs.getString("NAME"), "Hello");
-        assertEquals(rs.getByte("XT"), -1);
+        assertEquals("Hello", rs.getString("NAME"));
+        assertEquals(-1, rs.getByte("XT"));
         BigDecimal bd = rs.getBigDecimal("XD");
         assertTrue(bd.equals(new BigDecimal("10.30")));
         Timestamp ts = rs.getTimestamp("XTS");
         String s = ts.toString();
-        assertEquals(s, "2001-02-03 11:22:33.4455");
+        assertEquals("2001-02-03 11:22:33.4455", s);
         assertTrue(ts.equals(Timestamp.valueOf("2001-02-03 11:22:33.4455")));
-        assertEquals(rs.getBytes("XBY"), new byte[] { (byte) 255, (byte) 1, (byte) 2 });
+        assertEquals(new byte[] { (byte) 255, (byte) 1, (byte) 2 }, rs.getBytes("XBY"));
         assertTrue(rs.getBoolean("XBO"));
-        assertEquals(rs.getShort("XSM"), 3000);
-        assertEquals(rs.getLong("XBI"), 1234567890123456789L);
-        assertEquals(rs.getString("XBL"), "1122aa");
-        assertEquals(rs.getString("XDA"), "0002-01-01");
-        assertEquals(rs.getString("XTI"), "00:00:00");
-        assertEquals(rs.getString("XCL"), "J\u00fcrg");
-        assertEquals(rs.getString("XDO"), "2.25");
+        assertEquals(3000, rs.getShort("XSM"));
+        assertEquals(1234567890123456789L, rs.getLong("XBI"));
+        assertEquals("1122aa", rs.getString("XBL"));
+        assertEquals("0002-01-01", rs.getString("XDA"));
+        assertEquals("00:00:00", rs.getString("XTI"));
+        assertEquals("J\u00fcrg", rs.getString("XCL"));
+        assertEquals("2.25", rs.getString("XDO"));
     }
 
 }

h2/src/test/org/h2/test/db/TestLob.java

@@ -9,7 +9,6 @@ package org.h2.test.db;
 import java.io.ByteArrayInputStream;
 import java.io.CharArrayReader;
 import java.io.File;
-import java.io.IOException;
 import java.io.InputStream;
 import java.io.Reader;
 import java.io.StringReader;
@@ -324,7 +323,7 @@ public class TestLob extends TestBase {
         ResultSet rs = conn.createStatement().executeQuery("SELECT * FROM TEST");
         assertTrue(rs.next());
         rs.getInt(1);
-        assertEquals(rs.getString(2).length(), 10000);
+        assertEquals(10000, rs.getString(2).length());
         conn.close();
     }
 
@@ -449,7 +448,7 @@ public class TestLob extends TestBase {
         ResultSet rs;
         rs = stat.executeQuery("select value from information_schema.settings where NAME='COMPRESS_LOB'");
         rs.next();
-        assertEquals(rs.getString(1), compress ? "LZF" : "NO");
+        assertEquals(compress ? "LZF" : "NO", rs.getString(1));
         assertFalse(rs.next());
         stat.execute("create table test(text clob)");
         stat.execute("create table test2(text clob)");
@@ -462,15 +461,15 @@ public class TestLob extends TestBase {
         stat.execute("insert into test2 select * from test");
         rs = stat.executeQuery("select * from test2");
         rs.next();
-        assertEquals(rs.getString(1), spaces);
+        assertEquals(spaces, rs.getString(1));
         stat.execute("drop table test");
         rs = stat.executeQuery("select * from test2");
         rs.next();
-        assertEquals(rs.getString(1), spaces);
+        assertEquals(spaces, rs.getString(1));
         stat.execute("alter table test2 add column id int before text");
         rs = stat.executeQuery("select * from test2");
         rs.next();
-        assertEquals(rs.getString("text"), spaces);
+        assertEquals(spaces, rs.getString("text"));
         conn.close();
     }
 
@@ -545,10 +544,10 @@ public class TestLob extends TestBase {
             Blob b = rs.getBlob("B");
             Clob c = rs.getClob("C");
             int l = i;
-            assertEquals(b.length(), l);
-            assertEquals(c.length(), l);
-            checkStream(b.getBinaryStream(), getRandomStream(l, i), -1);
-            checkReader(c.getCharacterStream(), getRandomReader(l, i), -1);
+            assertEquals(l, b.length());
+            assertEquals(l, c.length());
+            assertEqualStreams(getRandomStream(l, i), b.getBinaryStream(), -1);
+            assertEqualReaders(getRandomReader(l, i), c.getCharacterStream(), -1);
         }
 
         prep = conn.prepareStatement("UPDATE TEST SET B=?, C=? WHERE ID=?");
@@ -567,10 +566,10 @@ public class TestLob extends TestBase {
             Blob b = rs.getBlob("B");
             Clob c = rs.getClob("C");
             int l = i;
-            assertEquals(b.length(), l);
-            assertEquals(c.length(), l);
-            checkStream(b.getBinaryStream(), getRandomStream(l, -i), -1);
-            checkReader(c.getCharacterStream(), getRandomReader(l, -i), -1);
+            assertEquals(l, b.length());
+            assertEquals(l, c.length());
+            assertEqualStreams(getRandomStream(l, -i), b.getBinaryStream(), -1);
+            assertEqualReaders(getRandomReader(l, -i), c.getCharacterStream(), -1);
         }
 
         conn.close();
@@ -594,21 +593,21 @@ public class TestLob extends TestBase {
         ResultSet rs = conn.createStatement().executeQuery("SELECT * FROM TEST ORDER BY ID");
         rs.next();
         assertEquals("Bohlen", rs.getString("C"));
-        checkReader(new CharArrayReader("Bohlen".toCharArray()), rs.getCharacterStream("C"), -1);
+        assertEqualReaders(new CharArrayReader("Bohlen".toCharArray()), rs.getCharacterStream("C"), -1);
         rs.next();
-        checkReader(new CharArrayReader("B\u00f6hlen".toCharArray()), rs.getCharacterStream("C"), -1);
+        assertEqualReaders(new CharArrayReader("B\u00f6hlen".toCharArray()), rs.getCharacterStream("C"), -1);
         rs.next();
-        checkReader(getRandomReader(501, 1), rs.getCharacterStream("C"), -1);
+        assertEqualReaders(getRandomReader(501, 1), rs.getCharacterStream("C"), -1);
         Clob clob = rs.getClob("C");
-        checkReader(getRandomReader(501, 1), clob.getCharacterStream(), -1);
-        assertEquals(clob.length(), 501);
+        assertEqualReaders(getRandomReader(501, 1), clob.getCharacterStream(), -1);
+        assertEquals(501, clob.length());
         rs.next();
-        checkReader(getRandomReader(401, 2), rs.getCharacterStream("C"), -1);
-        checkReader(getRandomReader(1500, 2), rs.getCharacterStream("C"), 401);
+        assertEqualReaders(getRandomReader(401, 2), rs.getCharacterStream("C"), -1);
+        assertEqualReaders(getRandomReader(1500, 2), rs.getCharacterStream("C"), 401);
         clob = rs.getClob("C");
-        checkReader(getRandomReader(1501, 2), clob.getCharacterStream(), 401);
-        checkReader(getRandomReader(401, 2), clob.getCharacterStream(), 401);
-        assertEquals(clob.length(), 401);
+        assertEqualReaders(getRandomReader(1501, 2), clob.getCharacterStream(), 401);
+        assertEqualReaders(getRandomReader(401, 2), clob.getCharacterStream(), 401);
+        assertEquals(401, clob.length());
         assertFalse(rs.next());
         conn.close();
     }
@@ -687,7 +686,7 @@ public class TestLob extends TestBase {
         stat = conn.createStatement();
         ResultSet rs = stat.executeQuery("SELECT * FROM TEST WHERE ID=1");
         rs.next();
-        checkStream(new ByteArrayInputStream(data), rs.getBinaryStream("TEXT"), -1);
+        assertEqualStreams(rs.getBinaryStream("TEXT"), new ByteArrayInputStream(data), -1);
 
         prep = conn.prepareStatement("UPDATE TEST SET TEXT = ?");
         prep.setBinaryStream(1, new ByteArrayInputStream(data), 0);
@@ -697,7 +696,7 @@ public class TestLob extends TestBase {
         stat = conn.createStatement();
         rs = stat.executeQuery("SELECT * FROM TEST WHERE ID=1");
         rs.next();
-        checkStream(new ByteArrayInputStream(data), rs.getBinaryStream("TEXT"), -1);
+        assertEqualStreams(rs.getBinaryStream("TEXT"), new ByteArrayInputStream(data), -1);
 
         stat.execute("DROP TABLE IF EXISTS TEST");
         conn.close();
@@ -743,20 +742,20 @@ public class TestLob extends TestBase {
             int size = id * id;
             if (clob) {
                 Reader rt = rs.getCharacterStream(2);
-                checkReader(rt, getRandomReader(size, id), -1);
+                assertEqualReaders(getRandomReader(size, id), rt, -1);
                 Object obj = rs.getObject(2);
                 if (obj instanceof Clob) {
                     obj = ((Clob) obj).getCharacterStream();
                 }
-                checkReader((Reader) obj, getRandomReader(size, id), -1);
+                assertEqualReaders(getRandomReader(size, id), (Reader) obj, -1);
             } else {
                 InputStream in = rs.getBinaryStream(2);
-                checkStream(in, getRandomStream(size, id), -1);
+                assertEqualStreams(getRandomStream(size, id), in, -1);
                 Object obj = rs.getObject(2);
                 if (obj instanceof Blob) {
                     obj = ((Blob) obj).getBinaryStream();
                 }
-                checkStream((InputStream) obj, getRandomStream(size, id), -1);
+                assertEqualStreams(getRandomStream(size, id), (InputStream) obj, -1);
             }
         }
         trace("select=" + (System.currentTimeMillis() - time));
@@ -808,49 +807,12 @@ public class TestLob extends TestBase {
         TestLobObject a = (TestLobObject) oa;
         Object ob = rs.getObject("DATA");
         TestLobObject b = (TestLobObject) ob;
-        assertEquals(a.data, "abc");
-        assertEquals(b.data, "abc");
+        assertEquals("abc", a.data);
+        assertEquals("abc", b.data);
         assertFalse(rs.next());
         conn.close();
     }
 
-    private void checkStream(InputStream a, InputStream b, int len) throws IOException {
-        // this doesn't actually read anything - just tests reading 0 bytes
-        a.read(new byte[0]);
-        b.read(new byte[0]);
-        a.read(new byte[10], 3, 0);
-        b.read(new byte[10], 0, 0);
-
-        for (int i = 0; len < 0 || i < len; i++) {
-            int ca = a.read();
-            a.read(new byte[0]);
-            int cb = b.read();
-            assertEquals(ca, cb);
-            if (ca == -1) {
-                break;
-            }
-        }
-        a.read(new byte[10], 3, 0);
-        b.read(new byte[10], 0, 0);
-        a.read(new byte[0]);
-        b.read(new byte[0]);
-        a.close();
-        b.close();
-    }
-
-    private void checkReader(Reader a, Reader b, int len) throws IOException {
-        for (int i = 0; len < 0 || i < len; i++) {
-            int ca = a.read();
-            int cb = b.read();
-            assertEquals(ca, cb);
-            if (ca == -1) {
-                break;
-            }
-        }
-        a.close();
-        b.close();
-    }
-
     private Reader getRandomReader(int len, int seed) {
         return new CharArrayReader(getRandomChars(len, seed));
     }

h2/src/test/org/h2/test/db/TestOpenClose.java

@@ -79,7 +79,7 @@ public class TestOpenClose extends TestBase implements DatabaseEventListener {
         stat = conn.createStatement();
         ResultSet rs = stat.executeQuery("SELECT * FROM TEST");
         rs.next();
-        assertEquals(rs.getString(1).length(), 10000);
+        assertEquals(10000, rs.getString(1).length());
         assertFalse(rs.next());
         conn.close();
         FileUtils.delete(baseDir + "/test.zip");
@@ -165,7 +165,7 @@ public class TestOpenClose extends TestBase implements DatabaseEventListener {
         conn = DriverManager.getConnection(url, user, password);
         ResultSet rs = conn.createStatement().executeQuery("select count(*) from employee");
         rs.next();
-        assertEquals(rs.getInt(1), len);
+        assertEquals(len, rs.getInt(1));
         conn.close();
     }
 

h2/src/test/org/h2/test/db/TestOptimizations.java

@@ -353,15 +353,15 @@ public class TestOptimizations extends TestBase {
         PreparedStatement prep = conn.prepareStatement("select * from test where id = (select id from test2)");
         ResultSet rs1 = prep.executeQuery();
         rs1.next();
-        assertEquals(rs1.getInt(1), 1);
+        assertEquals(1, rs1.getInt(1));
         rs1.next();
-        assertEquals(rs1.getInt(1), 1);
+        assertEquals(1, rs1.getInt(1));
         assertFalse(rs1.next());
 
         stat.execute("update test2 set id = 2");
         ResultSet rs2 = prep.executeQuery();
         rs2.next();
-        assertEquals(rs2.getInt(1), 2);
+        assertEquals(2, rs2.getInt(1));
 
         conn.close();
     }
@@ -455,8 +455,8 @@ public class TestOptimizations extends TestBase {
         prep.setInt(1, 1);
         rs = prep.executeQuery();
         rs.next();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(1, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         assertFalse(rs.next());
 
         prep = conn.prepareStatement("select * from test t1 where t1.id in(?, ?) order by id");
@@ -464,29 +464,30 @@ public class TestOptimizations extends TestBase {
         prep.setInt(2, 2);
         rs = prep.executeQuery();
         rs.next();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(1, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         rs.next();
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getString(2), "World");
+        assertEquals(2, rs.getInt(1));
+        assertEquals("World", rs.getString(2));
         assertFalse(rs.next());
 
-        prep = conn.prepareStatement("select * from test t1 where t1.id in(select t2.id from test t2 where t2.id=?)");
+        prep = conn.prepareStatement("select * from test t1 where t1.id "
+                + "in(select t2.id from test t2 where t2.id=?)");
         prep.setInt(1, 2);
         rs = prep.executeQuery();
         rs.next();
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getString(2), "World");
+        assertEquals(2, rs.getInt(1));
+        assertEquals("World", rs.getString(2));
         assertFalse(rs.next());
 
-        prep = conn
-                .prepareStatement("select * from test t1 where t1.id in(select t2.id from test t2 where t2.id=? and t1.id<>t2.id)");
+        prep = conn.prepareStatement("select * from test t1 where t1.id "
+                + "in(select t2.id from test t2 where t2.id=? and t1.id<>t2.id)");
         prep.setInt(1, 2);
         rs = prep.executeQuery();
         assertFalse(rs.next());
 
-        prep = conn
-                .prepareStatement("select * from test t1 where t1.id in(select t2.id from test t2 where t2.id in(cast(?+10 as varchar)))");
+        prep = conn.prepareStatement("select * from test t1 where t1.id "
+                + "in(select t2.id from test t2 where t2.id in(cast(?+10 as varchar)))");
         prep.setInt(1, 2);
         rs = prep.executeQuery();
         assertFalse(rs.next());

h2/src/test/org/h2/test/db/TestPowerOff.java

@@ -90,14 +90,14 @@ public class TestPowerOff extends TestBase {
             ResultSet rs = stat.executeQuery("SELECT * FROM TEST" + i + " ORDER BY ID");
             for (int j = 0; j < 10; j++) {
                 rs.next();
-                assertEquals(rs.getInt(1), j);
-                assertEquals(rs.getString(2), "Hello");
+                assertEquals(j, rs.getInt(1));
+                assertEquals("Hello", rs.getString(2));
             }
             if (i == 1) {
                 for (int j = 0; j < 10; j++) {
                     rs.next();
-                    assertEquals(rs.getInt(1), j + 10);
-                    assertEquals(rs.getString(2), "World");
+                    assertEquals(j + 10, rs.getInt(1));
+                    assertEquals("World", rs.getString(2));
                 }
             }
             assertFalse(rs.next());
@@ -219,7 +219,7 @@ public class TestPowerOff extends TestBase {
         stat = conn.createStatement();
         ResultSet rs = stat.executeQuery("SELECT COUNT(*) FROM TEST");
         rs.next();
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         conn.close();
     }
 
@@ -317,18 +317,18 @@ public class TestPowerOff extends TestBase {
             if (!rs.next()) {
                 state = 1;
             } else {
-                assertEquals(rs.getInt(1), 1);
+                assertEquals(1, rs.getInt(1));
                 String name1 = rs.getString(2);
                 assertTrue(rs.next());
-                assertEquals(rs.getInt(1), 2);
+                assertEquals(2, rs.getInt(1));
                 String name2 = rs.getString(2);
                 assertFalse(rs.next());
                 if ("Hello".equals(name1)) {
-                    assertEquals(name2, "World");
+                    assertEquals("World", name2);
                     state = 2;
                 } else {
-                    assertEquals(name1, "Hallo");
-                    assertEquals(name2, "Welt");
+                    assertEquals("Hallo", name1);
+                    assertEquals("Welt", name2);
                     state = 3;
                 }
             }

h2/src/test/org/h2/test/db/TestRights.java

@@ -271,7 +271,7 @@ public class TestRights extends TestBase {
         ResultSet rs = conn.createStatement().executeQuery(
                 "SELECT STORAGE_TYPE FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME='TEST'");
         rs.next();
-        assertEquals(rs.getString(1), type);
+        assertEquals(type, rs.getString(1));
         executeSuccess("DROP TABLE TEST");
     }
 

h2/src/test/org/h2/test/db/TestSequence.java

@@ -76,11 +76,11 @@ public class TestSequence extends TestBase {
         stat.execute("call next value for test_Sequence3");
         ResultSet rs = stat.executeQuery("select * from information_schema.sequences order by sequence_name");
         rs.next();
-        assertEquals(rs.getString("SEQUENCE_NAME"), "TEST_SEQUENCE");
-        assertEquals(rs.getString("CACHE"), "32");
+        assertEquals("TEST_SEQUENCE", rs.getString("SEQUENCE_NAME"));
+        assertEquals("32", rs.getString("CACHE"));
         rs.next();
-        assertEquals(rs.getString("SEQUENCE_NAME"), "TEST_SEQUENCE3");
-        assertEquals(rs.getString("CACHE"), "3");
+        assertEquals("TEST_SEQUENCE3", rs.getString("SEQUENCE_NAME"));
+        assertEquals("3", rs.getString("CACHE"));
         assertFalse(rs.next());
         conn.close();
     }

h2/src/test/org/h2/test/db/TestTriggersConstraints.java

@@ -123,12 +123,12 @@ public class TestTriggersConstraints extends TestBase implements Trigger {
 
         rs = stat.executeQuery("SELECT * FROM TEST");
         rs.next();
-        assertEquals(rs.getString(2), "Hello-updated");
+        assertEquals("Hello-updated", rs.getString(2));
         assertFalse(rs.next());
         stat.execute("UPDATE TEST SET NAME=NAME||'-upd'");
         rs = stat.executeQuery("SELECT * FROM TEST");
         rs.next();
-        assertEquals(rs.getString(2), "Hello-updated-upd-updated2");
+        assertEquals("Hello-updated-upd-updated2", rs.getString(2));
         assertFalse(rs.next());
 
         mustNotCallTrigger = true;

h2/src/test/org/h2/test/db/TestTwoPhaseCommit.java

@@ -52,12 +52,12 @@ public class TestTwoPhaseCommit extends TestBase {
         stat.execute("SET WRITE_DELAY 0");
         ResultSet rs = stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
         rs.next();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(1, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         if (!rolledBack) {
             rs.next();
-            assertEquals(rs.getInt(1), 2);
-            assertEquals(rs.getString(2), "World");
+            assertEquals(2, rs.getInt(1));
+            assertEquals("World", rs.getString(2));
         }
         assertFalse(rs.next());
         conn.close();

h2/src/test/org/h2/test/jdbc/TestMetaData.java

@@ -65,31 +65,31 @@ public class TestMetaData extends TestBase {
 
         rs = meta.getCatalogs();
         rs.next();
-        assertEquals(rs.getString(1), catalog);
+        assertEquals(catalog, rs.getString(1));
         assertFalse(rs.next());
 
         rs = meta.getSchemas();
         rs.next();
-        assertEquals(rs.getString("TABLE_SCHEM"), "INFORMATION_SCHEMA");
+        assertEquals("INFORMATION_SCHEMA", rs.getString("TABLE_SCHEM"));
         rs.next();
-        assertEquals(rs.getString("TABLE_SCHEM"), "PUBLIC");
+        assertEquals("PUBLIC", rs.getString("TABLE_SCHEM"));
         assertFalse(rs.next());
 
         rs = meta.getTableTypes();
         rs.next();
-        assertEquals(rs.getString("TABLE_TYPE"), "SYSTEM TABLE");
+        assertEquals("SYSTEM TABLE", rs.getString("TABLE_TYPE"));
         rs.next();
-        assertEquals(rs.getString("TABLE_TYPE"), "TABLE");
+        assertEquals("TABLE", rs.getString("TABLE_TYPE"));
         rs.next();
-        assertEquals(rs.getString("TABLE_TYPE"), "TABLE LINK");
+        assertEquals("TABLE LINK", rs.getString("TABLE_TYPE"));
         rs.next();
-        assertEquals(rs.getString("TABLE_TYPE"), "VIEW");
+        assertEquals("VIEW", rs.getString("TABLE_TYPE"));
         assertFalse(rs.next());
 
         rs = meta.getTables(null, Constants.SCHEMA_MAIN, null, new String[] { "TABLE" });
         assertTrue(rs.getStatement() == null);
         rs.next();
-        assertEquals(rs.getString("TABLE_NAME"), "TEST");
+        assertEquals("TEST", rs.getString("TABLE_NAME"));
         assertFalse(rs.next());
 
         rs = meta.getTables(null, "INFORMATION_SCHEMA", null, new String[] { "TABLE", "SYSTEM TABLE" });
@@ -153,36 +153,36 @@ public class TestMetaData extends TestBase {
 
         rs = meta.getColumns(null, null, "TEST", null);
         rs.next();
-        assertEquals(rs.getString("COLUMN_NAME"), "ID");
+        assertEquals("ID", rs.getString("COLUMN_NAME"));
         rs.next();
-        assertEquals(rs.getString("COLUMN_NAME"), "NAME");
+        assertEquals("NAME", rs.getString("COLUMN_NAME"));
         assertFalse(rs.next());
 
         rs = meta.getPrimaryKeys(null, null, "TEST");
         rs.next();
-        assertEquals(rs.getString("COLUMN_NAME"), "ID");
+        assertEquals("ID", rs.getString("COLUMN_NAME"));
         assertFalse(rs.next());
 
         rs = meta.getBestRowIdentifier(null, null, "TEST", DatabaseMetaData.bestRowSession, false);
         rs.next();
-        assertEquals(rs.getString("COLUMN_NAME"), "ID");
+        assertEquals("ID", rs.getString("COLUMN_NAME"));
         assertFalse(rs.next());
 
         rs = meta.getIndexInfo(null, null, "TEST", false, false);
         rs.next();
         String index = rs.getString("INDEX_NAME");
         assertTrue(index.startsWith("PRIMARY_KEY"));
-        assertEquals(rs.getString("COLUMN_NAME"), "ID");
+        assertEquals("ID", rs.getString("COLUMN_NAME"));
         rs.next();
-        assertEquals(rs.getString("INDEX_NAME"), "IDXNAME");
-        assertEquals(rs.getString("COLUMN_NAME"), "NAME");
+        assertEquals("IDXNAME", rs.getString("INDEX_NAME"));
+        assertEquals("NAME", rs.getString("COLUMN_NAME"));
         assertFalse(rs.next());
 
         rs = meta.getIndexInfo(null, null, "TEST", true, false);
         rs.next();
         index = rs.getString("INDEX_NAME");
         assertTrue(index.startsWith("PRIMARY_KEY"));
-        assertEquals(rs.getString("COLUMN_NAME"), "ID");
+        assertEquals("ID", rs.getString("COLUMN_NAME"));
         assertFalse(rs.next());
 
         rs = meta.getVersionColumns(null, null, "TEST");
@@ -377,7 +377,7 @@ public class TestMetaData extends TestBase {
         ResultSet rs = stat.executeQuery("SELECT STORAGE_TYPE FROM "
                 + "INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME='TEST_TEMP'");
         rs.next();
-        assertEquals(rs.getString("STORAGE_TYPE"), "GLOBAL TEMPORARY");
+        assertEquals("GLOBAL TEMPORARY", rs.getString("STORAGE_TYPE"));
         stat.execute("DROP TABLE IF EXISTS TEST_TEMP");
         conn.close();
     }
@@ -389,7 +389,7 @@ public class TestMetaData extends TestBase {
         assertEquals(dr.getMinorVersion(), meta.getDriverMinorVersion());
         assertTrue(dr.jdbcCompliant());
 
-        assertEquals(dr.getPropertyInfo(null, null).length, 0);
+        assertEquals(0, dr.getPropertyInfo(null, null).length);
         assertTrue(dr.connect("jdbc:test:false", null) == null);
 
         assertTrue(meta.getNumericFunctions().length() > 0);
@@ -405,54 +405,54 @@ public class TestMetaData extends TestBase {
         assertFalse(meta.deletesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
         assertFalse(meta.deletesAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
         assertFalse(meta.doesMaxRowSizeIncludeBlobs());
-        assertEquals(meta.getCatalogSeparator(), ".");
-        assertEquals(meta.getCatalogTerm(), "catalog");
+        assertEquals(".", meta.getCatalogSeparator());
+        assertEquals("catalog", meta.getCatalogTerm());
         assertTrue(meta.getConnection() == conn);
         if (config.jdk14) {
             String versionStart = meta.getDatabaseMajorVersion() + "." + meta.getDatabaseMinorVersion();
             assertTrue(meta.getDatabaseProductVersion().startsWith(versionStart));
-            assertEquals(meta.getDriverMajorVersion(), meta.getDatabaseMajorVersion());
-            assertEquals(meta.getDriverMinorVersion(), meta.getDatabaseMinorVersion());
-            assertEquals(meta.getJDBCMajorVersion(), 3);
-            assertEquals(meta.getJDBCMinorVersion(), 0);
+            assertEquals(meta.getDatabaseMajorVersion(), meta.getDriverMajorVersion());
+            assertEquals(meta.getDatabaseMinorVersion(), meta.getDriverMinorVersion());
+            assertEquals(3, meta.getJDBCMajorVersion());
+            assertEquals(0, meta.getJDBCMinorVersion());
         }
-        assertEquals(meta.getDatabaseProductName(), "H2");
-        assertEquals(meta.getDefaultTransactionIsolation(), Connection.TRANSACTION_READ_COMMITTED);
-        assertEquals(meta.getDriverName(), "H2 JDBC Driver");
+        assertEquals("H2", meta.getDatabaseProductName());
+        assertEquals(Connection.TRANSACTION_READ_COMMITTED, meta.getDefaultTransactionIsolation());
+        assertEquals("H2 JDBC Driver", meta.getDriverName());
 
         String versionStart = meta.getDriverMajorVersion() + "." + meta.getDriverMinorVersion();
         assertTrue(meta.getDriverVersion().startsWith(versionStart));
-        assertEquals(meta.getExtraNameCharacters(), "");
-        assertEquals(meta.getIdentifierQuoteString(), "\"");
-        assertEquals(meta.getMaxBinaryLiteralLength(), 0);
-        assertEquals(meta.getMaxCatalogNameLength(), 0);
-        assertEquals(meta.getMaxCharLiteralLength(), 0);
-        assertEquals(meta.getMaxColumnNameLength(), 0);
-        assertEquals(meta.getMaxColumnsInGroupBy(), 0);
-        assertEquals(meta.getMaxColumnsInIndex(), 0);
-        assertEquals(meta.getMaxColumnsInOrderBy(), 0);
-        assertEquals(meta.getMaxColumnsInSelect(), 0);
-        assertEquals(meta.getMaxColumnsInTable(), 0);
-        assertEquals(meta.getMaxConnections(), 0);
-        assertEquals(meta.getMaxCursorNameLength(), 0);
-        assertEquals(meta.getMaxIndexLength(), 0);
-        assertEquals(meta.getMaxProcedureNameLength(), 0);
-        assertEquals(meta.getMaxRowSize(), 0);
-        assertEquals(meta.getMaxSchemaNameLength(), 0);
-        assertEquals(meta.getMaxStatementLength(), 0);
-        assertEquals(meta.getMaxStatements(), 0);
-        assertEquals(meta.getMaxTableNameLength(), 0);
-        assertEquals(meta.getMaxTablesInSelect(), 0);
-        assertEquals(meta.getMaxUserNameLength(), 0);
-        assertEquals(meta.getProcedureTerm(), "procedure");
+        assertEquals("", meta.getExtraNameCharacters());
+        assertEquals("\"", meta.getIdentifierQuoteString());
+        assertEquals(0, meta.getMaxBinaryLiteralLength());
+        assertEquals(0, meta.getMaxCatalogNameLength());
+        assertEquals(0, meta.getMaxCharLiteralLength());
+        assertEquals(0, meta.getMaxColumnNameLength());
+        assertEquals(0, meta.getMaxColumnsInGroupBy());
+        assertEquals(0, meta.getMaxColumnsInIndex());
+        assertEquals(0, meta.getMaxColumnsInOrderBy());
+        assertEquals(0, meta.getMaxColumnsInSelect());
+        assertEquals(0, meta.getMaxColumnsInTable());
+        assertEquals(0, meta.getMaxConnections());
+        assertEquals(0, meta.getMaxCursorNameLength());
+        assertEquals(0, meta.getMaxIndexLength());
+        assertEquals(0, meta.getMaxProcedureNameLength());
+        assertEquals(0, meta.getMaxRowSize());
+        assertEquals(0, meta.getMaxSchemaNameLength());
+        assertEquals(0, meta.getMaxStatementLength());
+        assertEquals(0, meta.getMaxStatements());
+        assertEquals(0, meta.getMaxTableNameLength());
+        assertEquals(0, meta.getMaxTablesInSelect());
+        assertEquals(0, meta.getMaxUserNameLength());
+        assertEquals("procedure", meta.getProcedureTerm());
         if (config.jdk14) {
-            assertEquals(meta.getResultSetHoldability(), ResultSet.CLOSE_CURSORS_AT_COMMIT);
-            assertEquals(meta.getSQLStateType(), DatabaseMetaData.sqlStateSQL99);
+            assertEquals(ResultSet.CLOSE_CURSORS_AT_COMMIT, meta.getResultSetHoldability());
+            assertEquals(DatabaseMetaData.sqlStateSQL99, meta.getSQLStateType());
             assertFalse(meta.locatorsUpdateCopy());
         }
-        assertEquals(meta.getSchemaTerm(), "schema");
-        assertEquals(meta.getSearchStringEscape(), "\\");
-        assertEquals(meta.getSQLKeywords(), "LIMIT,MINUS,ROWNUM,SYSDATE,SYSTIME,SYSTIMESTAMP,TODAY");
+        assertEquals("schema", meta.getSchemaTerm());
+        assertEquals("\\", meta.getSearchStringEscape());
+        assertEquals("LIMIT,MINUS,ROWNUM,SYSDATE,SYSTIME,SYSTIMESTAMP,TODAY", meta.getSQLKeywords());
 
         assertTrue(meta.getURL().startsWith("jdbc:h2:"));
         assertTrue(meta.getUserName().length() > 1);
@@ -834,9 +834,9 @@ public class TestMetaData extends TestBase {
         assertResultSetMeta(rs, 3, new String[] { "TABLE_SCHEM", "TABLE_CATALOG", "IS_DEFAULT" }, new int[] {
                 Types.VARCHAR, Types.VARCHAR, DataType.TYPE_BOOLEAN }, null, null);
         assertTrue(rs.next());
-        assertEquals(rs.getString(1), "INFORMATION_SCHEMA");
+        assertEquals("INFORMATION_SCHEMA", rs.getString(1));
         assertTrue(rs.next());
-        assertEquals(rs.getString(1), "PUBLIC");
+        assertEquals("PUBLIC", rs.getString(1));
         assertFalse(rs.next());
 
         rs = meta.getCatalogs();

h2/src/test/org/h2/test/jdbc/TestPreparedStatement.java

@@ -172,7 +172,7 @@ public class TestPreparedStatement extends TestBase {
         prep.execute();
         rs = stat.executeQuery("SELECT COUNT(DISTINCT H) FROM TEST");
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
 
         stat.execute("DROP TABLE TEST");
     }
@@ -192,7 +192,7 @@ public class TestPreparedStatement extends TestBase {
         prep.setString(1, "X");
         rs = prep.executeQuery();
         rs.next();
-        assertEquals(rs.getInt(1), 0);
+        assertEquals(0, rs.getInt(1));
 
         stat.execute("CREATE TABLE t1 (c1 INT, c2 VARCHAR(10))");
         stat.execute("INSERT INTO t1 SELECT X, CONCAT('Test', X)  FROM SYSTEM_RANGE(1, 5);");
@@ -203,11 +203,11 @@ public class TestPreparedStatement extends TestBase {
         prep.setInt(1, 2);
         rs = prep.executeQuery();
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
         prep.setInt(1, 3);
         rs = prep.executeQuery();
         rs.next();
-        assertEquals(rs.getInt(1), 3);
+        assertEquals(3, rs.getInt(1));
         stat.execute("DROP TABLE t1, t2");
 
     }
@@ -267,7 +267,7 @@ public class TestPreparedStatement extends TestBase {
         prep.setInt(1, 1);
         ResultSet rs = prep.executeQuery();
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 0);
+        assertEquals(0, rs.getInt(1));
         assertFalse(rs.next());
     }
 
@@ -284,13 +284,13 @@ public class TestPreparedStatement extends TestBase {
     private void testPreparedStatementMetaData(Connection conn) throws SQLException {
         PreparedStatement prep = conn.prepareStatement("select * from table(x int = ?, name varchar = ?)");
         ResultSetMetaData meta = prep.getMetaData();
-        assertEquals(meta.getColumnCount(), 2);
-        assertEquals(meta.getColumnTypeName(1), "INTEGER");
-        assertEquals(meta.getColumnTypeName(2), "VARCHAR");
+        assertEquals(2, meta.getColumnCount());
+        assertEquals("INTEGER", meta.getColumnTypeName(1));
+        assertEquals("VARCHAR", meta.getColumnTypeName(2));
         prep = conn.prepareStatement("call 1");
         meta = prep.getMetaData();
-        assertEquals(meta.getColumnCount(), 1);
-        assertEquals(meta.getColumnTypeName(1), "INTEGER");
+        assertEquals(1, meta.getColumnCount());
+        assertEquals("INTEGER", meta.getColumnTypeName(1));
     }
 
     private void testArray(Connection conn) throws SQLException {
@@ -298,9 +298,9 @@ public class TestPreparedStatement extends TestBase {
         prep.setObject(1, new Object[] { new BigDecimal("1"), "2" });
         ResultSet rs = prep.executeQuery();
         rs.next();
-        assertEquals(rs.getString(1), "1");
+        assertEquals("1", rs.getString(1));
         rs.next();
-        assertEquals(rs.getString(1), "2");
+        assertEquals("2", rs.getString(1));
         assertFalse(rs.next());
     }
 
@@ -326,7 +326,7 @@ public class TestPreparedStatement extends TestBase {
         ResultSet rs = stat.getGeneratedKeys();
         rs.next();
         byte[] data = rs.getBytes(1);
-        assertEquals(data.length, 16);
+        assertEquals(16, data.length);
         stat.execute("DROP TABLE TEST_UUID");
     }
 
@@ -353,7 +353,7 @@ public class TestPreparedStatement extends TestBase {
         assertTrue(o instanceof byte[]);
         o = rs.getObject(3);
         assertTrue(o instanceof Integer);
-        assertEquals(((Integer) o).intValue(), 103);
+        assertEquals(103, ((Integer) o).intValue());
         assertFalse(rs.next());
         stat.execute("DROP TABLE TEST");
     }
@@ -377,16 +377,16 @@ public class TestPreparedStatement extends TestBase {
         PreparedStatement p = conn.prepareStatement("UPDATE TEST SET FLAG=true WHERE ID=(SELECT ?)");
         p.clearParameters();
         p.setLong(1, 0);
-        assertEquals(p.executeUpdate(), 1);
+        assertEquals(1, p.executeUpdate());
         p.clearParameters();
         p.setLong(1, 1);
-        assertEquals(p.executeUpdate(), 1);
+        assertEquals(1, p.executeUpdate());
         ResultSet rs = u.executeQuery();
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 0);
+        assertEquals(0, rs.getInt(1));
         assertTrue(rs.getBoolean(2));
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         assertTrue(rs.getBoolean(2));
 
         p = conn.prepareStatement("SELECT * FROM TEST WHERE EXISTS(SELECT * FROM TEST WHERE ID=?)");
@@ -403,14 +403,14 @@ public class TestPreparedStatement extends TestBase {
     private void testParameterMetaData(Connection conn) throws SQLException {
         PreparedStatement prep = conn.prepareStatement("SELECT ?, ?, ? FROM DUAL");
         ParameterMetaData pm = prep.getParameterMetaData();
-        assertEquals(pm.getParameterClassName(1), "java.lang.String");
-        assertEquals(pm.getParameterTypeName(1), "VARCHAR");
-        assertEquals(pm.getParameterCount(), 3);
-        assertEquals(pm.getParameterMode(1), ParameterMetaData.parameterModeIn);
-        assertEquals(pm.getParameterType(1), Types.VARCHAR);
-        assertEquals(pm.getPrecision(1), 0);
-        assertEquals(pm.getScale(1), 0);
-        assertEquals(pm.isNullable(1), ResultSetMetaData.columnNullableUnknown);
+        assertEquals("java.lang.String", pm.getParameterClassName(1));
+        assertEquals("VARCHAR", pm.getParameterTypeName(1));
+        assertEquals(3, pm.getParameterCount());
+        assertEquals(ParameterMetaData.parameterModeIn, pm.getParameterMode(1));
+        assertEquals(Types.VARCHAR, pm.getParameterType(1));
+        assertEquals(0, pm.getPrecision(1));
+        assertEquals(0, pm.getScale(1));
+        assertEquals(ResultSetMetaData.columnNullableUnknown, pm.isNullable(1));
         assertEquals(pm.isSigned(1), true);
         try {
             pm.getPrecision(0);
@@ -467,7 +467,7 @@ public class TestPreparedStatement extends TestBase {
         PreparedStatement prep, prepExe;
 
         prep = conn.prepareStatement("EXPLAIN SELECT * FROM TEST WHERE NAME LIKE ?");
-        assertEquals(prep.getParameterMetaData().getParameterCount(), 1);
+        assertEquals(1, prep.getParameterMetaData().getParameterCount());
         prepExe = conn.prepareStatement("SELECT * FROM TEST WHERE NAME LIKE ?");
         prep.setString(1, "%orld");
         prepExe.setString(1, "%orld");
@@ -477,7 +477,7 @@ public class TestPreparedStatement extends TestBase {
         assertTrue(plan.indexOf("TABLE_SCAN") >= 0);
         rs = prepExe.executeQuery();
         rs.next();
-        assertEquals(rs.getString(2), "World");
+        assertEquals("World", rs.getString(2));
         assertFalse(rs.next());
 
         prep.setString(1, "H%");
@@ -488,7 +488,7 @@ public class TestPreparedStatement extends TestBase {
         assertTrue(plan1.indexOf("IDXNAME") >= 0);
         rs = prepExe.executeQuery();
         rs.next();
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals("Hello", rs.getString(2));
         assertFalse(rs.next());
 
         stat.execute("DROP TABLE IF EXISTS TEST");
@@ -519,7 +519,7 @@ public class TestPreparedStatement extends TestBase {
         prep.setInt(1, 1);
         rs = prep.executeQuery();
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         assertFalse(rs.next());
 
         prep = conn
@@ -527,7 +527,7 @@ public class TestPreparedStatement extends TestBase {
         prep.setInt(1, 1);
         rs = prep.executeQuery();
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         assertFalse(rs.next());
 
         prep = conn.prepareStatement("SELECT * FROM TEST WHERE ? IS NULL");
@@ -541,13 +541,13 @@ public class TestPreparedStatement extends TestBase {
             assertKnownException(e);
         }
         prep = conn.prepareStatement("select cast(? as varchar) from dual union select ? from dual");
-        assertEquals(prep.getParameterMetaData().getParameterCount(), 2);
+        assertEquals(2, prep.getParameterMetaData().getParameterCount());
         prep.setString(1, "a");
         prep.setString(2, "a");
         rs = prep.executeQuery();
         rs.next();
-        assertEquals(rs.getString(1), "a");
-        assertEquals(rs.getString(1), "a");
+        assertEquals("a", rs.getString(1));
+        assertEquals("a", rs.getString(1));
         assertFalse(rs.next());
 
         stat.execute("DROP TABLE TEST");
@@ -559,15 +559,15 @@ public class TestPreparedStatement extends TestBase {
         stat.execute("INSERT INTO TEST VALUES(1),(2),(3)");
         PreparedStatement prep = conn.prepareStatement("select x.id, ? from "
                 + "(select * from test where id in(?, ?)) x where x.id*2 <>  ?");
-        assertEquals(prep.getParameterMetaData().getParameterCount(), 4);
+        assertEquals(4, prep.getParameterMetaData().getParameterCount());
         prep.setInt(1, 0);
         prep.setInt(2, 1);
         prep.setInt(3, 2);
         prep.setInt(4, 4);
         ResultSet rs = prep.executeQuery();
         rs.next();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getInt(2), 0);
+        assertEquals(1, rs.getInt(1));
+        assertEquals(0, rs.getInt(2));
         assertFalse(rs.next());
         stat.execute("DROP TABLE TEST");
     }
@@ -739,11 +739,11 @@ public class TestPreparedStatement extends TestBase {
         assertTrue(rs.getObject(8).equals(new Float(Float.MAX_VALUE)));
         assertTrue(rs.getObject(9).equals(new Double(Double.MAX_VALUE)));
         assertTrue(rs.getObject(10).equals(java.sql.Date.valueOf("2001-02-03")));
-        assertEquals(rs.getObject(11).toString(), "04:05:06");
+        assertEquals("04:05:06", rs.getObject(11).toString());
         assertTrue(rs.getObject(11).equals(java.sql.Time.valueOf("04:05:06")));
         assertTrue(rs.getObject(12).equals(java.sql.Timestamp.valueOf("2001-02-03 04:05:06.123456789")));
         assertTrue(rs.getObject(13).equals(java.sql.Timestamp.valueOf("2001-02-03 00:00:00")));
-        assertEquals((byte[]) rs.getObject(14), new byte[] { 10, 20, 30 });
+        assertEquals(new byte[] { 10, 20, 30 }, (byte[]) rs.getObject(14));
         assertTrue(rs.getObject(15).equals(new Character('a')));
         assertTrue(rs.getObject(16).equals(java.sql.Date.valueOf("2001-01-02")));
         assertTrue(rs.getObject(17) == null && rs.wasNull());
@@ -772,25 +772,25 @@ public class TestPreparedStatement extends TestBase {
         prep.execute();
         ResultSet rs = prep.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         assertFalse(rs.next());
         prep = conn.prepareStatement("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", Statement.RETURN_GENERATED_KEYS);
         prep.execute();
         rs = prep.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
         assertFalse(rs.next());
         prep = conn.prepareStatement("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new int[] { 1 });
         prep.execute();
         rs = prep.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 3);
+        assertEquals(3, rs.getInt(1));
         assertFalse(rs.next());
         prep = conn.prepareStatement("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new String[] { "ID" });
         prep.execute();
         rs = prep.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 4);
+        assertEquals(4, rs.getInt(1));
         assertFalse(rs.next());
         stat.execute("DROP TABLE TEST");
     }
@@ -855,29 +855,29 @@ public class TestPreparedStatement extends TestBase {
         rs = stat.executeQuery("SELECT ID, V1, V2 FROM T_BLOB ORDER BY ID");
 
         rs.next();
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         assertTrue(rs.getBytes(2) == null && rs.wasNull());
         assertTrue(rs.getBytes(3) == null && rs.wasNull());
 
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
         assertTrue(rs.getBytes(2) == null && rs.wasNull());
         assertTrue(rs.getBytes(3) == null && rs.wasNull());
 
         rs.next();
-        assertEquals(rs.getInt(1), 3);
-        assertEquals(rs.getBytes(2), big1);
-        assertEquals(rs.getBytes(3), big2);
+        assertEquals(3, rs.getInt(1));
+        assertEquals(big1, rs.getBytes(2));
+        assertEquals(big2, rs.getBytes(3));
 
         rs.next();
-        assertEquals(rs.getInt(1), 4);
-        assertEquals(rs.getBytes(2), big2);
-        assertEquals(rs.getBytes(3), big1);
+        assertEquals(4, rs.getInt(1));
+        assertEquals(big2, rs.getBytes(2));
+        assertEquals(big1, rs.getBytes(3));
 
         rs.next();
-        assertEquals(rs.getInt(1), 5);
-        assertEquals(rs.getBytes(2), big2);
-        assertEquals(rs.getBytes(3), big1);
+        assertEquals(5, rs.getInt(1));
+        assertEquals(big2, rs.getBytes(2));
+        assertEquals(big1, rs.getBytes(3));
 
         assertFalse(rs.next());
     }
@@ -933,29 +933,29 @@ public class TestPreparedStatement extends TestBase {
         rs = stat.executeQuery("SELECT ID, V1, V2 FROM T_CLOB ORDER BY ID");
 
         rs.next();
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         assertTrue(rs.getCharacterStream(2) == null && rs.wasNull());
         assertTrue(rs.getAsciiStream(3) == null && rs.wasNull());
 
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
         assertTrue(rs.getString(2) == null && rs.wasNull());
         assertTrue(rs.getString(3) == null && rs.wasNull());
 
         rs.next();
-        assertEquals(rs.getInt(1), 3);
-        assertEquals(rs.getString(2), ascii1);
-        assertEquals(rs.getString(3), ascii2);
+        assertEquals(3, rs.getInt(1));
+        assertEquals(ascii1, rs.getString(2));
+        assertEquals(ascii2, rs.getString(3));
 
         rs.next();
-        assertEquals(rs.getInt(1), 4);
-        assertEquals(rs.getString(2), ascii2);
-        assertEquals(rs.getString(3), ascii1);
+        assertEquals(4, rs.getInt(1));
+        assertEquals(ascii2, rs.getString(2));
+        assertEquals(ascii1, rs.getString(3));
 
         rs.next();
-        assertEquals(rs.getInt(1), 5);
-        assertEquals(rs.getString(2), ascii1);
-        assertEquals(rs.getString(3), ascii2);
+        assertEquals(5, rs.getInt(1));
+        assertEquals(ascii1, rs.getString(2));
+        assertEquals(ascii2, rs.getString(3));
 
         assertFalse(rs.next());
         assertTrue(prep.getWarnings() == null);

h2/src/test/org/h2/test/jdbc/TestResultSet.java

@@ -219,35 +219,35 @@ public class TestResultSet extends TestBase {
         ResultSet rs;
         stat.execute("CREATE TABLE TEST(ID INT, NAME VARCHAR)");
         rs = stat.executeQuery("SELECT * FROM TEST");
-        assertEquals(rs.findColumn("ID"), 1);
-        assertEquals(rs.findColumn("NAME"), 2);
-        assertEquals(rs.findColumn("id"), 1);
-        assertEquals(rs.findColumn("name"), 2);
-        assertEquals(rs.findColumn("Id"), 1);
-        assertEquals(rs.findColumn("Name"), 2);
-        assertEquals(rs.findColumn("TEST.ID"), 1);
-        assertEquals(rs.findColumn("TEST.NAME"), 2);
-        assertEquals(rs.findColumn("Test.Id"), 1);
-        assertEquals(rs.findColumn("Test.Name"), 2);
+        assertEquals(1, rs.findColumn("ID"));
+        assertEquals(2, rs.findColumn("NAME"));
+        assertEquals(1, rs.findColumn("id"));
+        assertEquals(2, rs.findColumn("name"));
+        assertEquals(1, rs.findColumn("Id"));
+        assertEquals(2, rs.findColumn("Name"));
+        assertEquals(1, rs.findColumn("TEST.ID"));
+        assertEquals(2, rs.findColumn("TEST.NAME"));
+        assertEquals(1, rs.findColumn("Test.Id"));
+        assertEquals(2, rs.findColumn("Test.Name"));
         stat.execute("DROP TABLE TEST");
 
         stat.execute("CREATE TABLE TEST(ID INT, NAME VARCHAR, DATA VARCHAR)");
         rs = stat.executeQuery("SELECT * FROM TEST");
-        assertEquals(rs.findColumn("ID"), 1);
-        assertEquals(rs.findColumn("NAME"), 2);
-        assertEquals(rs.findColumn("DATA"), 3);
-        assertEquals(rs.findColumn("id"), 1);
-        assertEquals(rs.findColumn("name"), 2);
-        assertEquals(rs.findColumn("data"), 3);
-        assertEquals(rs.findColumn("Id"), 1);
-        assertEquals(rs.findColumn("Name"), 2);
-        assertEquals(rs.findColumn("Data"), 3);
-        assertEquals(rs.findColumn("TEST.ID"), 1);
-        assertEquals(rs.findColumn("TEST.NAME"), 2);
-        assertEquals(rs.findColumn("TEST.DATA"), 3);
-        assertEquals(rs.findColumn("Test.Id"), 1);
-        assertEquals(rs.findColumn("Test.Name"), 2);
-        assertEquals(rs.findColumn("Test.Data"), 3);
+        assertEquals(1, rs.findColumn("ID"));
+        assertEquals(2, rs.findColumn("NAME"));
+        assertEquals(3, rs.findColumn("DATA"));
+        assertEquals(1, rs.findColumn("id"));
+        assertEquals(2, rs.findColumn("name"));
+        assertEquals(3, rs.findColumn("data"));
+        assertEquals(1, rs.findColumn("Id"));
+        assertEquals(2, rs.findColumn("Name"));
+        assertEquals(3, rs.findColumn("Data"));
+        assertEquals(1, rs.findColumn("TEST.ID"));
+        assertEquals(2, rs.findColumn("TEST.NAME"));
+        assertEquals(3, rs.findColumn("TEST.DATA"));
+        assertEquals(1, rs.findColumn("Test.Id"));
+        assertEquals(2, rs.findColumn("Test.Name"));
+        assertEquals(3, rs.findColumn("Test.Data"));
         stat.execute("DROP TABLE TEST");
 
     }
@@ -318,21 +318,21 @@ public class TestResultSet extends TestBase {
         stat.execute("INSERT INTO TEST(NAME) VALUES('Hello')");
         rs = stat.getGeneratedKeys();
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
 
         stat.execute("INSERT INTO TEST(NAME) VALUES('World')");
         rs = stat.getGeneratedKeys();
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
 
         rs = stat.executeQuery("SELECT ID AS I, NAME AS N, ID+1 AS IP1 FROM TEST");
         ResultSetMetaData meta = rs.getMetaData();
         assertTrue(meta.isAutoIncrement(1));
         assertFalse(meta.isAutoIncrement(2));
         assertFalse(meta.isAutoIncrement(3));
-        assertEquals(meta.isNullable(1), ResultSetMetaData.columnNoNulls);
-        assertEquals(meta.isNullable(2), ResultSetMetaData.columnNullable);
-        assertEquals(meta.isNullable(3), ResultSetMetaData.columnNullableUnknown);
+        assertEquals(ResultSetMetaData.columnNoNulls, meta.isNullable(1));
+        assertEquals(ResultSetMetaData.columnNullable, meta.isNullable(2));
+        assertEquals(ResultSetMetaData.columnNullableUnknown, meta.isNullable(3));
         assertTrue(rs.next());
         assertTrue(rs.next());
         assertFalse(rs.next());
@@ -362,12 +362,12 @@ public class TestResultSet extends TestBase {
         rs = stat.executeQuery("SELECT *, NULL AS N FROM TEST ORDER BY ID");
 
         // MySQL compatibility
-        assertEquals(rs.findColumn("TEST.ID"), 1);
-        assertEquals(rs.findColumn("TEST.VALUE"), 2);
+        assertEquals(1, rs.findColumn("TEST.ID"));
+        assertEquals(2, rs.findColumn("TEST.VALUE"));
 
         ResultSetMetaData meta = rs.getMetaData();
-        assertEquals(meta.getColumnCount(), 3);
-        assertEquals(meta.getCatalogName(1), "resultSet".toUpperCase());
+        assertEquals(3, meta.getColumnCount());
+        assertEquals("resultSet".toUpperCase(), meta.getCatalogName(1));
         assertTrue("PUBLIC".equals(meta.getSchemaName(2)));
         assertTrue("TEST".equals(meta.getTableName(1)));
         assertTrue("ID".equals(meta.getColumnName(1)));
@@ -379,20 +379,20 @@ public class TestResultSet extends TestBase {
         assertTrue(meta.getColumnDisplaySize(1) > 0);
         assertTrue(meta.isSigned(1));
         assertTrue(meta.isSearchable(2));
-        assertEquals(meta.isNullable(1), ResultSetMetaData.columnNoNulls);
+        assertEquals(ResultSetMetaData.columnNoNulls, meta.isNullable(1));
         assertFalse(meta.isReadOnly(1));
         assertTrue(meta.isWritable(1));
         assertFalse(meta.isDefinitelyWritable(1));
         assertTrue(meta.getColumnDisplaySize(1) > 0);
         assertTrue(meta.getColumnDisplaySize(2) > 0);
-        assertEquals(meta.getColumnClassName(3), null);
+        assertEquals(null, meta.getColumnClassName(3));
 
         assertTrue(rs.getRow() == 0);
         assertResultSetMeta(rs, 3, new String[] { "ID", "VALUE", "N" }, new int[] { Types.INTEGER, Types.INTEGER,
                 Types.NULL }, new int[] { 10, 10, 1 }, new int[] { 0, 0, 0 });
         rs.next();
-        assertEquals(rs.getConcurrency(), ResultSet.CONCUR_READ_ONLY);
-        assertEquals(rs.getFetchDirection(), ResultSet.FETCH_FORWARD);
+        assertEquals(ResultSet.CONCUR_READ_ONLY, rs.getConcurrency());
+        assertEquals(ResultSet.FETCH_FORWARD, rs.getFetchDirection());
         trace("default fetch size=" + rs.getFetchSize());
         // 0 should be an allowed value (but it's not defined what is actually
         // means)
@@ -418,14 +418,14 @@ public class TestResultSet extends TestBase {
         rs.setFetchSize(6);
 
         assertTrue(rs.getRow() == 1);
-        assertEquals(rs.findColumn("VALUE"), 2);
-        assertEquals(rs.findColumn("value"), 2);
-        assertEquals(rs.findColumn("Value"), 2);
-        assertEquals(rs.findColumn("Value"), 2);
-        assertEquals(rs.findColumn("ID"), 1);
-        assertEquals(rs.findColumn("id"), 1);
-        assertEquals(rs.findColumn("Id"), 1);
-        assertEquals(rs.findColumn("iD"), 1);
+        assertEquals(2, rs.findColumn("VALUE"));
+        assertEquals(2, rs.findColumn("value"));
+        assertEquals(2, rs.findColumn("Value"));
+        assertEquals(2, rs.findColumn("Value"));
+        assertEquals(1, rs.findColumn("ID"));
+        assertEquals(1, rs.findColumn("id"));
+        assertEquals(1, rs.findColumn("Id"));
+        assertEquals(1, rs.findColumn("iD"));
         assertTrue(rs.getInt(2) == -1 && !rs.wasNull());
         assertTrue(rs.getInt("VALUE") == -1 && !rs.wasNull());
         assertTrue(rs.getInt("value") == -1 && !rs.wasNull());
@@ -488,7 +488,7 @@ public class TestResultSet extends TestBase {
         assertTrue(o == null);
         assertTrue(rs.wasNull());
         assertFalse(rs.next());
-        assertEquals(rs.getRow(), 0);
+        assertEquals(0, rs.getRow());
         // there is one more row, but because of setMaxRows we don't get it
 
         stat.execute("DROP TABLE TEST");
@@ -678,17 +678,17 @@ public class TestResultSet extends TestBase {
         assertTrue(bd.compareTo(new BigDecimal("0.00")) == 0);
         assertTrue(!rs.wasNull());
         rs.next();
-        assertEquals(rs.getDouble(2), 1.0);
-        assertEquals(rs.getFloat(3), 1.0f);
+        assertEquals(1.0, rs.getDouble(2));
+        assertEquals(1.0f, rs.getFloat(3));
         rs.next();
-        assertEquals(rs.getDouble(2), 12345678.89);
-        assertEquals(rs.getFloat(3), 12345678.89f);
+        assertEquals(12345678.89, rs.getDouble(2));
+        assertEquals(12345678.89f, rs.getFloat(3));
         rs.next();
-        assertEquals(rs.getDouble(2), 99999999.99);
-        assertEquals(rs.getFloat(3), 99999999.99f);
+        assertEquals(99999999.99, rs.getDouble(2));
+        assertEquals(99999999.99f, rs.getFloat(3));
         rs.next();
-        assertEquals(rs.getDouble(2), -99999999.99);
-        assertEquals(rs.getFloat(3), -99999999.99f);
+        assertEquals(-99999999.99, rs.getDouble(2));
+        assertEquals(-99999999.99f, rs.getFloat(3));
         rs.next();
         checkColumnBigDecimal(rs, 2, 0, null);
         checkColumnBigDecimal(rs, 3, 0, null);
@@ -726,9 +726,9 @@ public class TestResultSet extends TestBase {
         trace("Date: " + date.toString() + " Time:" + time.toString() + " Timestamp:" + ts.toString());
         trace("Date ms: " + date.getTime() + " Time ms:" + time.getTime() + " Timestamp ms:" + ts.getTime());
         trace("1970 ms: " + java.sql.Timestamp.valueOf("1970-01-01 00:00:00.0").getTime());
-        assertEquals(date.getTime(), java.sql.Timestamp.valueOf("2011-11-11 00:00:00.0").getTime());
-        assertEquals(time.getTime(), java.sql.Timestamp.valueOf("1970-01-01 00:00:00.0").getTime());
-        assertEquals(ts.getTime(), java.sql.Timestamp.valueOf("2011-11-11 00:00:00.0").getTime());
+        assertEquals(java.sql.Timestamp.valueOf("2011-11-11 00:00:00.0").getTime(), date.getTime());
+        assertEquals(java.sql.Timestamp.valueOf("1970-01-01 00:00:00.0").getTime(), time.getTime());
+        assertEquals(java.sql.Timestamp.valueOf("2011-11-11 00:00:00.0").getTime(), ts.getTime());
         assertTrue(date.equals(java.sql.Date.valueOf("2011-11-11")));
         assertTrue(time.equals(java.sql.Time.valueOf("00:00:00")));
         assertTrue(ts.equals(java.sql.Timestamp.valueOf("2011-11-11 00:00:00.0")));
@@ -747,17 +747,17 @@ public class TestResultSet extends TestBase {
         ts = rs.getTimestamp("VALUE");
         assertTrue(!rs.wasNull());
         trace("Date: " + date.toString() + " Time:" + time.toString() + " Timestamp:" + ts.toString());
-        assertEquals(date.toString(), "2002-02-02");
-        assertEquals(time.toString(), "02:02:02");
-        assertEquals(ts.toString(), "2002-02-02 02:02:02.0");
+        assertEquals("2002-02-02", date.toString());
+        assertEquals("02:02:02", time.toString());
+        assertEquals("2002-02-02 02:02:02.0", ts.toString());
         rs.next();
-        assertEquals(rs.getDate("value").toString(), "1800-01-01");
-        assertEquals(rs.getTime("value").toString(), "00:00:00");
-        assertEquals(rs.getTimestamp("value").toString(), "1800-01-01 00:00:00.0");
+        assertEquals("1800-01-01", rs.getDate("value").toString());
+        assertEquals("00:00:00", rs.getTime("value").toString());
+        assertEquals("1800-01-01 00:00:00.0", rs.getTimestamp("value").toString());
         rs.next();
-        assertEquals(rs.getDate("Value").toString(), "9999-12-31");
-        assertEquals(rs.getTime("Value").toString(), "23:59:59");
-        assertEquals(rs.getTimestamp("Value").toString(), "9999-12-31 23:59:59.0");
+        assertEquals("9999-12-31", rs.getDate("Value").toString());
+        assertEquals("23:59:59", rs.getTime("Value").toString());
+        assertEquals("9999-12-31 23:59:59.0", rs.getTimestamp("Value").toString());
         rs.next();
         assertTrue(rs.getDate("Value") == null && rs.wasNull());
         assertTrue(rs.getTime("vALUe") == null && rs.wasNull());
@@ -770,9 +770,9 @@ public class TestResultSet extends TestBase {
         date = (Date) rs.getObject(1);
         time = (Time) rs.getObject(2);
         ts = (Timestamp) rs.getObject(3);
-        assertEquals(date.toString(), "2001-02-03");
-        assertEquals(time.toString(), "14:15:16");
-        assertEquals(ts.toString(), "2007-08-09 10:11:12.141516171");
+        assertEquals("2001-02-03", date.toString());
+        assertEquals("14:15:16", time.toString());
+        assertEquals("2007-08-09 10:11:12.141516171", ts.toString());
 
         stat.execute("DROP TABLE TEST");
     }
@@ -831,39 +831,39 @@ public class TestResultSet extends TestBase {
                 Types.TIME, Types.TIMESTAMP }, new int[] { 10, 8, 6, 23 }, new int[] { 0, 0, 0, 10 });
 
         rs.next();
-        assertEquals(rs.getInt(1), 0);
+        assertEquals(0, rs.getInt(1));
         assertTrue(rs.getDate(2, regular) == null && rs.wasNull());
         assertTrue(rs.getTime(3, regular) == null && rs.wasNull());
         assertTrue(rs.getTimestamp(3, regular) == null && rs.wasNull());
 
         rs.next();
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         assertTrue(rs.getDate(2, other) == null && rs.wasNull());
         assertTrue(rs.getTime(3, other) == null && rs.wasNull());
         assertTrue(rs.getTimestamp(3, other) == null && rs.wasNull());
 
         rs.next();
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getDate(2, regular).toString(), "2001-02-03");
-        assertEquals(rs.getTime(3, regular).toString(), "04:05:06");
+        assertEquals(2, rs.getInt(1));
+        assertEquals("2001-02-03", rs.getDate(2, regular).toString());
+        assertEquals("04:05:06", rs.getTime(3, regular).toString());
         assertFalse(rs.getTime(3, other).toString().equals("04:05:06"));
-        assertEquals(rs.getTimestamp(4, regular).toString(), "2007-08-09 10:11:12.131415");
+        assertEquals("2007-08-09 10:11:12.131415", rs.getTimestamp(4, regular).toString());
         assertFalse(rs.getTimestamp(4, other).toString().equals("2007-08-09 10:11:12.131415"));
 
         rs.next();
-        assertEquals(rs.getInt("ID"), 3);
+        assertEquals(3, rs.getInt("ID"));
         assertFalse(rs.getTimestamp("TS", regular).toString().equals("2107-08-09 10:11:12.131415"));
-        assertEquals(rs.getTimestamp("TS", other).toString(), "2107-08-09 10:11:12.131415");
+        assertEquals("2107-08-09 10:11:12.131415", rs.getTimestamp("TS", other).toString());
         assertFalse(rs.getTime("T", regular).toString().equals("14:05:06"));
-        assertEquals(rs.getTime("T", other).toString(), "14:05:06");
+        assertEquals("14:05:06", rs.getTime("T", other).toString());
         // checkFalse(rs.getDate(2, regular).toString(), "2101-02-03");
         // check(rs.getDate("D", other).toString(), "2101-02-03");
 
         rs.next();
-        assertEquals(rs.getInt("ID"), 4);
-        assertEquals(rs.getTimestamp("TS").toString(), "2107-08-09 10:11:12.131415");
-        assertEquals(rs.getTime("T").toString(), "14:05:06");
-        assertEquals(rs.getDate("D").toString(), "2101-02-03");
+        assertEquals(4, rs.getInt("ID"));
+        assertEquals("2107-08-09 10:11:12.131415", rs.getTimestamp("TS").toString());
+        assertEquals("14:05:06", rs.getTime("T").toString());
+        assertEquals("2101-02-03", rs.getDate("D").toString());
 
         assertFalse(rs.next());
         stat.execute("DROP TABLE TEST");
@@ -884,24 +884,24 @@ public class TestResultSet extends TestBase {
         assertResultSetMeta(rs, 2, new String[] { "ID", "VALUE" }, new int[] { Types.INTEGER, Types.BLOB }, new int[] {
                 10, Integer.MAX_VALUE }, new int[] { 0, 0 });
         rs.next();
-        checkBytes(rs.getBytes(2), new byte[] { (byte) 0x01, (byte) 0x01, (byte) 0x01, (byte) 0x01 });
+        assertEqualsWithNull(new byte[] { (byte) 0x01, (byte) 0x01, (byte) 0x01, (byte) 0x01 }, rs.getBytes(2));
         assertTrue(!rs.wasNull());
         rs.next();
-        checkBytes(rs.getBytes("value"), new byte[] { (byte) 0x02, (byte) 0x02, (byte) 0x02, (byte) 0x02 });
+        assertEqualsWithNull(new byte[] { (byte) 0x02, (byte) 0x02, (byte) 0x02, (byte) 0x02 }, rs.getBytes("value"));
         assertTrue(!rs.wasNull());
         rs.next();
-        checkBytes(readAllBytes(rs.getBinaryStream(2)), new byte[] { (byte) 0x00 });
+        assertEqualsWithNull(new byte[] { (byte) 0x00 }, readAllBytes(rs.getBinaryStream(2)));
         assertTrue(!rs.wasNull());
         rs.next();
-        checkBytes(readAllBytes(rs.getBinaryStream("VaLuE")), new byte[] { (byte) 0xff, (byte) 0xff, (byte) 0xff });
+        assertEqualsWithNull(new byte[] { (byte) 0xff, (byte) 0xff, (byte) 0xff }, readAllBytes(rs.getBinaryStream("VaLuE")));
         assertTrue(!rs.wasNull());
         rs.next();
         InputStream in = rs.getBinaryStream("value");
         byte[] b = readAllBytes(in);
-        checkBytes(b, new byte[] { (byte) 0x0b, (byte) 0xce, (byte) 0xc1 });
+        assertEqualsWithNull(new byte[] { (byte) 0x0b, (byte) 0xce, (byte) 0xc1 }, b);
         assertTrue(!rs.wasNull());
         rs.next();
-        checkBytes(readAllBytes(rs.getBinaryStream("VaLuE")), null);
+        assertEqualsWithNull(null, readAllBytes(rs.getBinaryStream("VaLuE")));
         assertTrue(rs.wasNull());
         assertTrue(!rs.next());
         stat.execute("DROP TABLE TEST");
@@ -975,8 +975,8 @@ public class TestResultSet extends TestBase {
         assertTrue(rs.getWarnings() == null);
         rs.clearWarnings();
         assertTrue(rs.getWarnings() == null);
-        assertEquals(rs.getFetchDirection(), ResultSet.FETCH_FORWARD);
-        assertEquals(rs.getConcurrency(), ResultSet.CONCUR_UPDATABLE);
+        assertEquals(ResultSet.FETCH_FORWARD, rs.getFetchDirection());
+        assertEquals(ResultSet.CONCUR_UPDATABLE, rs.getConcurrency());
         rs.next();
         stat.execute("DROP TABLE TEST");
     }
@@ -994,27 +994,27 @@ public class TestResultSet extends TestBase {
         prep.execute();
         rs = stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
         rs.next();
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         Object[] list = (Object[]) rs.getObject(2);
-        assertEquals(((Integer) list[0]).intValue(), 1);
-        assertEquals(((Integer) list[1]).intValue(), 2);
+        assertEquals(1, ((Integer) list[0]).intValue());
+        assertEquals(2, ((Integer) list[1]).intValue());
         Array array = rs.getArray(2);
         Object[] list2 = (Object[]) array.getArray();
-        assertEquals(((Integer) list2[0]).intValue(), 1);
-        assertEquals(((Integer) list2[1]).intValue(), 2);
+        assertEquals(1, ((Integer) list2[0]).intValue());
+        assertEquals(2, ((Integer) list2[1]).intValue());
         list2 = (Object[]) array.getArray(2, 1);
-        assertEquals(((Integer) list2[0]).intValue(), 2);
+        assertEquals(2, ((Integer) list2[0]).intValue());
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
         list = (Object[]) rs.getObject(2);
-        assertEquals(((Integer) list[0]).intValue(), 11);
-        assertEquals(((Integer) list[1]).intValue(), 12);
+        assertEquals(11, ((Integer) list[0]).intValue());
+        assertEquals(12, ((Integer) list[1]).intValue());
         array = rs.getArray(2);
         list2 = (Object[]) array.getArray();
-        assertEquals(((Integer) list2[0]).intValue(), 11);
-        assertEquals(((Integer) list2[1]).intValue(), 12);
+        assertEquals(11, ((Integer) list2[0]).intValue());
+        assertEquals(12, ((Integer) list2[1]).intValue());
         list2 = (Object[]) array.getArray(2, 1);
-        assertEquals(((Integer) list2[0]).intValue(), 12);
+        assertEquals(12, ((Integer) list2[0]).intValue());
         assertFalse(rs.next());
         stat.execute("DROP TABLE TEST");
     }
@@ -1039,11 +1039,11 @@ public class TestResultSet extends TestBase {
         }
     }
 
-    private void checkBytes(byte[] test, byte[] good) {
-        if (test == null || good == null) {
-            assertTrue(test == good);
+    private void assertEqualsWithNull(byte[] expected, byte[] got) {
+        if (got == null || expected == null) {
+            assertTrue(got == expected);
         } else {
-            assertEquals(test, good);
+            assertEquals(got, expected);
         }
     }
 

h2/src/test/org/h2/test/jdbc/TestStatement.java

@@ -193,9 +193,9 @@ public class TestStatement extends TestBase {
         // calls are ignored
 
         if (config.jdk14) {
-            assertEquals(stat.getResultSetHoldability(), ResultSet.HOLD_CURSORS_OVER_COMMIT);
+            assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, stat.getResultSetHoldability());
         }
-        assertEquals(stat.getResultSetConcurrency(), ResultSet.CONCUR_READ_ONLY);
+        assertEquals(ResultSet.CONCUR_READ_ONLY, stat.getResultSetConcurrency());
 
         stat.cancel();
         stat.setQueryTimeout(10);
@@ -212,22 +212,22 @@ public class TestStatement extends TestBase {
         assertTrue(stat.getQueryTimeout() == 0);
         trace("executeUpdate");
         count = stat.executeUpdate("CREATE TABLE TEST(ID INT PRIMARY KEY,VALUE VARCHAR(255))");
-        assertEquals(count, 0);
+        assertEquals(0, count);
         count = stat.executeUpdate("INSERT INTO TEST VALUES(1,'Hello')");
-        assertEquals(count, 1);
+        assertEquals(1, count);
         count = stat.executeUpdate("INSERT INTO TEST(VALUE,ID) VALUES('JDBC',2)");
-        assertEquals(count, 1);
+        assertEquals(1, count);
         count = stat.executeUpdate("UPDATE TEST SET VALUE='LDBC' WHERE ID=2 OR ID=1");
-        assertEquals(count, 2);
+        assertEquals(2, count);
         count = stat.executeUpdate("UPDATE TEST SET VALUE='\\LDBC\\' WHERE VALUE LIKE 'LDBC' ");
-        assertEquals(count, 2);
+        assertEquals(2, count);
         count = stat.executeUpdate("UPDATE TEST SET VALUE='LDBC' WHERE VALUE LIKE '\\\\LDBC\\\\'");
         trace("count:" + count);
-        assertEquals(count, 2);
+        assertEquals(2, count);
         count = stat.executeUpdate("DELETE FROM TEST WHERE ID=-1");
-        assertEquals(count, 0);
+        assertEquals(0, count);
         count = stat.executeUpdate("DELETE FROM TEST WHERE ID=2");
-        assertEquals(count, 1);
+        assertEquals(1, count);
         try {
             stat.executeUpdate("SELECT * FROM TEST");
             fail("executeUpdate allowed SELECT");
@@ -349,37 +349,37 @@ public class TestStatement extends TestBase {
         stat.execute("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)");
         ResultSet rs = stat.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 1);
+        assertEquals(1, rs.getInt(1));
         assertFalse(rs.next());
         stat.execute("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", Statement.RETURN_GENERATED_KEYS);
         rs = stat.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 2);
+        assertEquals(2, rs.getInt(1));
         assertFalse(rs.next());
         stat.execute("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new int[] { 1 });
         rs = stat.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 3);
+        assertEquals(3, rs.getInt(1));
         assertFalse(rs.next());
         stat.execute("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new String[] { "ID" });
         rs = stat.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 4);
+        assertEquals(4, rs.getInt(1));
         assertFalse(rs.next());
         stat.executeUpdate("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", Statement.RETURN_GENERATED_KEYS);
         rs = stat.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 5);
+        assertEquals(5, rs.getInt(1));
         assertFalse(rs.next());
         stat.executeUpdate("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new int[] { 1 });
         rs = stat.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 6);
+        assertEquals(6, rs.getInt(1));
         assertFalse(rs.next());
         stat.executeUpdate("INSERT INTO TEST VALUES(NEXT VALUE FOR SEQ)", new String[] { "ID" });
         rs = stat.getGeneratedKeys();
         rs.next();
-        assertEquals(rs.getInt(1), 7);
+        assertEquals(7, rs.getInt(1));
         assertFalse(rs.next());
         stat.execute("DROP TABLE TEST");
     }

h2/src/test/org/h2/test/jdbc/TestTransactionIsolation.java

@@ -38,17 +38,17 @@ public class TestTransactionIsolation extends TestBase {
     private void testTableLevelLocking() throws SQLException {
         deleteDb("transactionIsolation");
         conn1 = getConnection("transactionIsolation");
-        assertEquals(conn1.getTransactionIsolation(), Connection.TRANSACTION_READ_COMMITTED);
+        assertEquals(Connection.TRANSACTION_READ_COMMITTED, conn1.getTransactionIsolation());
         conn1.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
-        assertEquals(conn1.getTransactionIsolation(), Connection.TRANSACTION_SERIALIZABLE);
+        assertEquals(Connection.TRANSACTION_SERIALIZABLE, conn1.getTransactionIsolation());
         conn1.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
-        assertEquals(conn1.getTransactionIsolation(), Connection.TRANSACTION_READ_UNCOMMITTED);
+        assertEquals(Connection.TRANSACTION_READ_UNCOMMITTED, conn1.getTransactionIsolation());
         assertSingleValue(conn1.createStatement(), "CALL LOCK_MODE()", 0);
         conn1.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
         assertSingleValue(conn1.createStatement(), "CALL LOCK_MODE()", 3);
-        assertEquals(conn1.getTransactionIsolation(), Connection.TRANSACTION_READ_COMMITTED);
+        assertEquals(Connection.TRANSACTION_READ_COMMITTED, conn1.getTransactionIsolation());
         conn1.createStatement().execute("SET LOCK_MODE 1");
-        assertEquals(conn1.getTransactionIsolation(), Connection.TRANSACTION_SERIALIZABLE);
+        assertEquals(Connection.TRANSACTION_SERIALIZABLE, conn1.getTransactionIsolation());
         conn1.createStatement().execute("CREATE TABLE TEST(ID INT)");
         conn1.createStatement().execute("INSERT INTO TEST VALUES(1)");
         conn1.setAutoCommit(false);

h2/src/test/org/h2/test/jdbc/TestUpdatableResultSet.java

@@ -108,13 +108,13 @@ public class TestUpdatableResultSet extends TestBase {
 
         assertTrue(rs.isBeforeFirst());
         assertFalse(rs.isAfterLast());
-        assertEquals(rs.getRow(), 0);
+        assertEquals(0, rs.getRow());
 
         rs.next();
         assertFalse(rs.isBeforeFirst());
         assertFalse(rs.isAfterLast());
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getRow(), 1);
+        assertEquals(1, rs.getInt(1));
+        assertEquals(1, rs.getRow());
 
         rs.next();
 
@@ -127,54 +127,54 @@ public class TestUpdatableResultSet extends TestBase {
 
         assertFalse(rs.isBeforeFirst());
         assertFalse(rs.isAfterLast());
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getRow(), 2);
+        assertEquals(2, rs.getInt(1));
+        assertEquals(2, rs.getRow());
 
         rs.next();
         assertFalse(rs.isBeforeFirst());
         assertFalse(rs.isAfterLast());
-        assertEquals(rs.getInt(1), 3);
-        assertEquals(rs.getRow(), 3);
+        assertEquals(3, rs.getInt(1));
+        assertEquals(3, rs.getRow());
 
         assertFalse(rs.next());
         assertFalse(rs.isBeforeFirst());
         assertTrue(rs.isAfterLast());
-        assertEquals(rs.getRow(), 0);
+        assertEquals(0, rs.getRow());
 
         assertTrue(rs.first());
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getRow(), 1);
+        assertEquals(1, rs.getInt(1));
+        assertEquals(1, rs.getRow());
 
         assertTrue(rs.last());
-        assertEquals(rs.getInt(1), 3);
-        assertEquals(rs.getRow(), 3);
+        assertEquals(3, rs.getInt(1));
+        assertEquals(3, rs.getRow());
 
         assertTrue(rs.relative(0));
-        assertEquals(rs.getRow(), 3);
+        assertEquals(3, rs.getRow());
 
         assertTrue(rs.relative(-1));
-        assertEquals(rs.getRow(), 2);
+        assertEquals(2, rs.getRow());
 
         assertTrue(rs.relative(1));
-        assertEquals(rs.getRow(), 3);
+        assertEquals(3, rs.getRow());
 
         assertFalse(rs.relative(100));
         assertTrue(rs.isAfterLast());
 
         assertFalse(rs.absolute(0));
-        assertEquals(rs.getRow(), 0);
+        assertEquals(0, rs.getRow());
 
         assertTrue(rs.absolute(1));
-        assertEquals(rs.getRow(), 1);
+        assertEquals(1, rs.getRow());
 
         assertTrue(rs.absolute(2));
-        assertEquals(rs.getRow(), 2);
+        assertEquals(2, rs.getRow());
 
         assertTrue(rs.absolute(3));
-        assertEquals(rs.getRow(), 3);
+        assertEquals(3, rs.getRow());
 
         assertFalse(rs.absolute(4));
-        assertEquals(rs.getRow(), 0);
+        assertEquals(0, rs.getRow());
 
         try {
             assertFalse(rs.absolute(0));
@@ -185,10 +185,10 @@ public class TestUpdatableResultSet extends TestBase {
         }
 
         assertTrue(rs.absolute(3));
-        assertEquals(rs.getRow(), 3);
+        assertEquals(3, rs.getRow());
 
         assertTrue(rs.absolute(-1));
-        assertEquals(rs.getRow(), 3);
+        assertEquals(3, rs.getRow());
 
         assertFalse(rs.absolute(4));
         assertTrue(rs.isAfterLast());
@@ -197,10 +197,10 @@ public class TestUpdatableResultSet extends TestBase {
         assertTrue(rs.isAfterLast());
 
         assertTrue(rs.previous());
-        assertEquals(rs.getRow(), 3);
+        assertEquals(3, rs.getRow());
 
         assertTrue(rs.previous());
-        assertEquals(rs.getRow(), 2);
+        assertEquals(2, rs.getRow());
 
         conn.close();
     }
@@ -215,26 +215,26 @@ public class TestUpdatableResultSet extends TestBase {
                 + "O_I INT, SH SMALLINT, CL CLOB, BL BLOB)");
         ResultSet rs = stat.executeQuery("SELECT * FROM TEST");
         ResultSetMetaData meta = rs.getMetaData();
-        assertEquals(meta.getColumnClassName(1), "java.lang.Integer");
-        assertEquals(meta.getColumnClassName(2), "java.lang.String");
-        assertEquals(meta.getColumnClassName(3), "java.math.BigDecimal");
-        assertEquals(meta.getColumnClassName(4), "java.lang.Boolean");
-        assertEquals(meta.getColumnClassName(5), "java.lang.Byte");
-        assertEquals(meta.getColumnClassName(6), "[B");
-        assertEquals(meta.getColumnClassName(7), "java.sql.Date");
-        assertEquals(meta.getColumnClassName(8), "java.sql.Time");
-        assertEquals(meta.getColumnClassName(9), "java.sql.Timestamp");
-        assertEquals(meta.getColumnClassName(10), "java.lang.Double");
-        assertEquals(meta.getColumnClassName(11), "java.lang.Float");
-        assertEquals(meta.getColumnClassName(12), "java.lang.Long");
-        assertEquals(meta.getColumnClassName(13), "java.lang.Integer");
-        assertEquals(meta.getColumnClassName(14), "java.lang.Short");
+        assertEquals("java.lang.Integer", meta.getColumnClassName(1));
+        assertEquals("java.lang.String", meta.getColumnClassName(2));
+        assertEquals("java.math.BigDecimal", meta.getColumnClassName(3));
+        assertEquals("java.lang.Boolean", meta.getColumnClassName(4));
+        assertEquals("java.lang.Byte", meta.getColumnClassName(5));
+        assertEquals("[B", meta.getColumnClassName(6));
+        assertEquals("java.sql.Date", meta.getColumnClassName(7));
+        assertEquals("java.sql.Time", meta.getColumnClassName(8));
+        assertEquals("java.sql.Timestamp", meta.getColumnClassName(9));
+        assertEquals("java.lang.Double", meta.getColumnClassName(10));
+        assertEquals("java.lang.Float", meta.getColumnClassName(11));
+        assertEquals("java.lang.Long", meta.getColumnClassName(12));
+        assertEquals("java.lang.Integer", meta.getColumnClassName(13));
+        assertEquals("java.lang.Short", meta.getColumnClassName(14));
         if (SysProperties.RETURN_LOB_OBJECTS) {
-            assertEquals(meta.getColumnClassName(15), "java.sql.Clob");
-            assertEquals(meta.getColumnClassName(16), "java.sql.Blob");
+            assertEquals("java.sql.Clob", meta.getColumnClassName(15));
+            assertEquals("java.sql.Blob", meta.getColumnClassName(16));
         } else {
-            assertEquals(meta.getColumnClassName(15), "java.io.Reader");
-            assertEquals(meta.getColumnClassName(16), "java.io.InputStream");
+            assertEquals("java.io.Reader", meta.getColumnClassName(15));
+            assertEquals("java.io.InputStream", meta.getColumnClassName(16));
         }
         rs.moveToInsertRow();
         rs.updateInt(1, 0);
@@ -316,27 +316,27 @@ public class TestUpdatableResultSet extends TestBase {
         assertTrue(rs.getLong(12) == 0 && !rs.wasNull());
         assertTrue(rs.getObject(13) == null && rs.wasNull());
         assertTrue(rs.getShort(14) == 0 && !rs.wasNull());
-        assertEquals(rs.getString(15), "test");
-        assertEquals(rs.getBytes(16), new byte[] { (byte) 0xff, 0x00 });
+        assertEquals("test", rs.getString(15));
+        assertEquals(new byte[] { (byte) 0xff, 0x00 }, rs.getBytes(16));
 
         rs.next();
         assertTrue(rs.getInt(1) == 2);
-        assertEquals(rs.getString(2), "+");
-        assertEquals(rs.getBigDecimal(3).toString(), "1.20");
+        assertEquals("+", rs.getString(2));
+        assertEquals("1.20", rs.getBigDecimal(3).toString());
         assertTrue(rs.getBoolean(4));
         assertTrue((rs.getByte(5) & 0xff) == 0xff);
-        assertEquals(rs.getBytes(6), new byte[] { 0x00, (byte) 0xff });
-        assertEquals(rs.getDate(7).toString(), "2005-09-21");
-        assertEquals(rs.getTime(8).toString(), "21:46:28");
-        assertEquals(rs.getTimestamp(9).toString(), "2005-09-21 21:47:09.567890123");
+        assertEquals(new byte[] { 0x00, (byte) 0xff }, rs.getBytes(6));
+        assertEquals("2005-09-21", rs.getDate(7).toString());
+        assertEquals("21:46:28", rs.getTime(8).toString());
+        assertEquals("2005-09-21 21:47:09.567890123", rs.getTimestamp(9).toString());
         assertTrue(rs.getDouble(10) == 1.725);
         assertTrue(rs.getFloat(11) == (float) 2.5);
         assertTrue(rs.getLong(12) == Long.MAX_VALUE);
-        assertEquals(((Integer) rs.getObject(13)).intValue(), 10);
+        assertEquals(10, ((Integer) rs.getObject(13)).intValue());
         assertTrue(rs.getShort(14) == Short.MIN_VALUE);
         // auml ouml uuml
-        assertEquals(rs.getString(15), "\u00ef\u00f6\u00fc");
-        assertEquals(rs.getBytes(16), new byte[] { (byte) 0xab, 0x12 });
+        assertEquals("\u00ef\u00f6\u00fc", rs.getString(15));
+        assertEquals(new byte[] { (byte) 0xab, 0x12 }, rs.getBytes(16));
 
         assertFalse(rs.next());
         stat.execute("DROP TABLE TEST");
@@ -379,14 +379,14 @@ public class TestUpdatableResultSet extends TestBase {
         while (rs.next()) {
             int id = rs.getInt(1);
             String name = rs.getString(2);
-            assertEquals(id % 2, 0);
+            assertEquals(0, id % 2);
             if (id >= max) {
                 assertEquals("Inserted " + id, rs.getString(2));
             } else {
                 if (id % 4 == 0) {
-                    assertEquals(rs.getString(2), "Updated Hello" + id + "+");
+                    assertEquals("Updated Hello" + id + "+", rs.getString(2));
                 } else {
-                    assertEquals(rs.getString(2), "Updated Hello" + id);
+                    assertEquals("Updated Hello" + id, rs.getString(2));
                 }
             }
             trace("id=" + id + " name=" + name);
@@ -424,16 +424,16 @@ public class TestUpdatableResultSet extends TestBase {
             error = true;
         }
         ResultSet rs = stat.executeQuery("SELECT * FROM TEST");
-        assertEquals(rs.getType(), type);
+        assertEquals(type, rs.getType());
 
-        checkState(rs, true, false, false, rows == 0);
+        assertState(rs, true, false, false, rows == 0);
         for (int i = 0; i < rows; i++) {
             rs.next();
-            checkState(rs, rows == 0, i == 0, i == rows - 1, rows == 0 || i == rows);
+            assertState(rs, rows == 0, i == 0, i == rows - 1, rows == 0 || i == rows);
         }
         try {
             rs.beforeFirst();
-            checkState(rs, true, false, false, rows == 0);
+            assertState(rs, true, false, false, rows == 0);
         } catch (SQLException e) {
             if (!error) {
                 throw e;
@@ -441,7 +441,7 @@ public class TestUpdatableResultSet extends TestBase {
         }
         try {
             rs.afterLast();
-            checkState(rs, false, false, false, true);
+            assertState(rs, false, false, false, true);
         } catch (SQLException e) {
             if (!error) {
                 throw e;
@@ -449,9 +449,9 @@ public class TestUpdatableResultSet extends TestBase {
         }
         try {
             boolean valid = rs.first();
-            assertEquals(valid, rows > 0);
+            assertEquals(rows > 0, valid);
             if (valid) {
-                checkState(rs, false, true, rows == 1, rows == 0);
+                assertState(rs, false, true, rows == 1, rows == 0);
             }
         } catch (SQLException e) {
             if (!error) {
@@ -460,9 +460,9 @@ public class TestUpdatableResultSet extends TestBase {
         }
         try {
             boolean valid = rs.last();
-            assertEquals(valid, rows > 0);
+            assertEquals(rows > 0, valid);
             if (valid) {
-                checkState(rs, false, rows == 1, true, rows == 0);
+                assertState(rs, false, rows == 1, true, rows == 0);
             }
         } catch (SQLException e) {
             if (!error) {
@@ -471,11 +471,11 @@ public class TestUpdatableResultSet extends TestBase {
         }
     }
 
-    private void checkState(ResultSet rs, boolean beforeFirst, boolean first, boolean last, boolean afterLast) throws SQLException {
-        assertEquals(rs.isBeforeFirst(), beforeFirst);
-        assertEquals(rs.isFirst(), first);
-        assertEquals(rs.isLast(), last);
-        assertEquals(rs.isAfterLast(), afterLast);
+    private void assertState(ResultSet rs, boolean beforeFirst, boolean first, boolean last, boolean afterLast) throws SQLException {
+        assertEquals(beforeFirst, rs.isBeforeFirst());
+        assertEquals(first, rs.isFirst());
+        assertEquals(last, rs.isLast());
+        assertEquals(afterLast, rs.isAfterLast());
     }
 
 }

h2/src/test/org/h2/test/jdbc/TestZloty.java

@@ -67,13 +67,13 @@ public class TestZloty extends TestBase {
         prep.execute();
         ResultSet rs = conn.createStatement().executeQuery("SELECT * FROM TEST ORDER BY ID");
         rs.next();
-        assertEquals(rs.getInt(1), 0);
-        assertEquals(rs.getBytes(2)[0], 0);
+        assertEquals(0, rs.getInt(1));
+        assertEquals(0, rs.getBytes(2)[0]);
         rs.next();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getBytes(2)[0], 1);
+        assertEquals(1, rs.getInt(1));
+        assertEquals(1, rs.getBytes(2)[0]);
         rs.getBytes(2)[0] = 2;
-        assertEquals(rs.getBytes(2)[0], 1);
+        assertEquals(1, rs.getBytes(2)[0]);
         assertFalse(rs.next());
         conn.close();
     }

h2/src/test/org/h2/test/jdbcx/TestDataSource.java

@@ -73,7 +73,7 @@ public class TestDataSource extends TestBase {
         XAResource res = xaConn.getXAResource();
         Connection conn = xaConn.getConnection();
         Xid[] list = res.recover(XAResource.TMSTARTRSCAN);
-        assertEquals(list.length, 0);
+        assertEquals(0, list.length);
         Statement stat = conn.createStatement();
         stat.execute("SELECT * FROM DUAL");
         conn.close();

h2/src/test/org/h2/test/mvcc/TestMvcc1.java

@@ -97,10 +97,10 @@ public class TestMvcc1 extends TestBase {
         s1.execute("CREATE TABLE TEST(ID INT, NAME VARCHAR, PRIMARY KEY(ID))");
         s1.execute("INSERT INTO TEST VALUES(1, 'Hello')");
         c1.commit();
-        assertResult(s2, "SELECT NAME FROM TEST WHERE ID=1", "Hello");
+        assertResult("Hello", s2, "SELECT NAME FROM TEST WHERE ID=1");
         s1.execute("UPDATE TEST SET NAME = 'Hallo' WHERE ID=1");
-        assertResult(s2, "SELECT NAME FROM TEST WHERE ID=1", "Hello");
-        assertResult(s1, "SELECT NAME FROM TEST WHERE ID=1", "Hallo");
+        assertResult("Hello", s2, "SELECT NAME FROM TEST WHERE ID=1");
+        assertResult("Hallo", s1, "SELECT NAME FROM TEST WHERE ID=1");
         s1.execute("DROP TABLE TEST");
         c1.commit();
         c2.commit();
@@ -139,9 +139,9 @@ public class TestMvcc1 extends TestBase {
         s1.execute("create table test(id int, name varchar)");
         s1.execute("insert into test values(1, 'A'), (2, 'B')");
         c1.commit();
-        assertResult(s1, "select count(*) from test where name<>'C'", "2");
+        assertResult("2", s1, "select count(*) from test where name<>'C'");
         s2.execute("update test set name='B2' where id=2");
-        assertResult(s1, "select count(*) from test where name<>'C'", "2");
+        assertResult("2", s1, "select count(*) from test where name<>'C'");
         c2.commit();
         s2.execute("drop table test");
         c2.rollback();
@@ -166,8 +166,8 @@ public class TestMvcc1 extends TestBase {
         s1.execute("create table test(id int primary key, name varchar(255))");
         s2.execute("insert into test values(4, 'Hello')");
         c2.rollback();
-        assertResult(s1, "select count(*) from test where name = 'Hello'", "0");
-        assertResult(s2, "select count(*) from test where name = 'Hello'", "0");
+        assertResult("0", s1, "select count(*) from test where name = 'Hello'");
+        assertResult("0", s2, "select count(*) from test where name = 'Hello'");
         c1.commit();
         c2.commit();
         s1.execute("DROP TABLE TEST");
@@ -175,10 +175,10 @@ public class TestMvcc1 extends TestBase {
         s1.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))");
         s1.execute("INSERT INTO TEST VALUES(1, 'Test')");
         c1.commit();
-        assertResult(s1, "select max(id) from test", "1");
+        assertResult("1", s1, "select max(id) from test");
         s1.execute("INSERT INTO TEST VALUES(2, 'World')");
         c1.rollback();
-        assertResult(s1, "select max(id) from test", "1");
+        assertResult("1", s1, "select max(id) from test");
         c1.commit();
         c2.commit();
         s1.execute("DROP TABLE TEST");
@@ -187,7 +187,7 @@ public class TestMvcc1 extends TestBase {
         s1.execute("create table test as select * from table(id int=(1, 2))");
         s1.execute("update test set id=1 where id=1");
         s1.execute("select max(id) from test");
-        assertResult(s1, "select max(id) from test", "2");
+        assertResult("2", s1, "select max(id) from test");
         c1.commit();
         c2.commit();
         s1.execute("DROP TABLE TEST");
@@ -195,12 +195,12 @@ public class TestMvcc1 extends TestBase {
         s1.execute("CREATE TABLE TEST(ID INT)");
         s1.execute("INSERT INTO TEST VALUES(1)");
         c1.commit();
-        assertResult(s2, "SELECT COUNT(*) FROM TEST", "1");
+        assertResult("1", s2, "SELECT COUNT(*) FROM TEST");
         s1.executeUpdate("DELETE FROM TEST");
-        assertResult(s2, "SELECT COUNT(*) FROM TEST", "1");
-        assertResult(s1, "SELECT COUNT(*) FROM TEST", "0");
+        assertResult("1", s2, "SELECT COUNT(*) FROM TEST");
+        assertResult("0", s1, "SELECT COUNT(*) FROM TEST");
         c1.commit();
-        assertResult(s2, "SELECT COUNT(*) FROM TEST", "0");
+        assertResult("0", s2, "SELECT COUNT(*) FROM TEST");
         c1.commit();
         c2.commit();
         s1.execute("DROP TABLE TEST");
@@ -209,39 +209,39 @@ public class TestMvcc1 extends TestBase {
         s1.execute("INSERT INTO TEST VALUES(1)");
         c1.commit();
         s1.execute("DELETE FROM TEST");
-        assertResult(s1, "SELECT COUNT(*) FROM TEST", "0");
+        assertResult("0", s1, "SELECT COUNT(*) FROM TEST");
         c1.commit();
-        assertResult(s1, "SELECT COUNT(*) FROM TEST", "0");
+        assertResult("0", s1, "SELECT COUNT(*) FROM TEST");
         s1.execute("INSERT INTO TEST VALUES(1)");
         s1.execute("DELETE FROM TEST");
         c1.commit();
-        assertResult(s1, "SELECT COUNT(*) FROM TEST", "0");
+        assertResult("0", s1, "SELECT COUNT(*) FROM TEST");
         s1.execute("DROP TABLE TEST");
 
         s1.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR)");
         s1.execute("INSERT INTO TEST VALUES(1, 'Hello'), (2, 'World')");
-        assertResult(s2, "SELECT COUNT(*) FROM TEST", "0");
+        assertResult("0", s2, "SELECT COUNT(*) FROM TEST");
         c1.commit();
-        assertResult(s2, "SELECT COUNT(*) FROM TEST", "2");
+        assertResult("2", s2, "SELECT COUNT(*) FROM TEST");
         s1.execute("INSERT INTO TEST VALUES(3, '!')");
         c1.rollback();
-        assertResult(s2, "SELECT COUNT(*) FROM TEST", "2");
+        assertResult("2", s2, "SELECT COUNT(*) FROM TEST");
         s1.execute("DROP TABLE TEST");
         c1.commit();
 
         s1.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR)");
         s1.execute("INSERT INTO TEST VALUES(1, 'Hello')");
         s1.execute("DELETE FROM TEST");
-        assertResult(s2, "SELECT COUNT(*) FROM TEST", "0");
+        assertResult("0", s2, "SELECT COUNT(*) FROM TEST");
         c1.commit();
-        assertResult(s2, "SELECT COUNT(*) FROM TEST", "0");
+        assertResult("0", s2, "SELECT COUNT(*) FROM TEST");
         s1.execute("DROP TABLE TEST");
         c1.commit();
 
         s1.execute("CREATE TABLE TEST(ID INT IDENTITY, NAME VARCHAR)");
         s1.execute("INSERT INTO TEST(NAME) VALUES('Ruebezahl')");
-        assertResult(s2, "SELECT COUNT(*) FROM TEST", "0");
-        assertResult(s1, "SELECT COUNT(*) FROM TEST", "1");
+        assertResult("0", s2, "SELECT COUNT(*) FROM TEST");
+        assertResult("1", s1, "SELECT COUNT(*) FROM TEST");
         s1.execute("DROP TABLE TEST");
         c1.commit();
 
@@ -315,7 +315,7 @@ public class TestMvcc1 extends TestBase {
                 try {
                     s.execute("UPDATE TEST SET NAME=" + i + " WHERE ID=" + random.nextInt(i));
                 } catch (SQLException e) {
-                    assertEquals(e.getErrorCode(), ErrorCode.CONCURRENT_UPDATE_1);
+                    assertEquals(ErrorCode.CONCURRENT_UPDATE_1, e.getErrorCode());
                 }
                 break;
             case 2:
@@ -339,22 +339,22 @@ public class TestMvcc1 extends TestBase {
 
         s1.execute("CREATE TABLE TEST(ID INT, NAME VARCHAR)");
         s1.execute("INSERT INTO TEST VALUES(1, 'Hello')");
-        assertResult(s2, "SELECT COUNT(*) FROM TEST WHERE NAME!='X'", "0");
-        assertResult(s1, "SELECT COUNT(*) FROM TEST WHERE NAME!='X'", "1");
+        assertResult("0", s2, "SELECT COUNT(*) FROM TEST WHERE NAME!='X'");
+        assertResult("1", s1, "SELECT COUNT(*) FROM TEST WHERE NAME!='X'");
         c1.commit();
-        assertResult(s2, "SELECT COUNT(*) FROM TEST WHERE NAME!='X'", "1");
-        assertResult(s2, "SELECT COUNT(*) FROM TEST WHERE NAME!='X'", "1");
+        assertResult("1", s2, "SELECT COUNT(*) FROM TEST WHERE NAME!='X'");
+        assertResult("1", s2, "SELECT COUNT(*) FROM TEST WHERE NAME!='X'");
         s1.execute("DROP TABLE TEST");
         c1.commit();
         c2.commit();
 
         s1.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR)");
         s1.execute("INSERT INTO TEST VALUES(1, 'Hello')");
-        assertResult(s2, "SELECT COUNT(*) FROM TEST WHERE ID<100", "0");
-        assertResult(s1, "SELECT COUNT(*) FROM TEST WHERE ID<100", "1");
+        assertResult("0", s2, "SELECT COUNT(*) FROM TEST WHERE ID<100");
+        assertResult("1", s1, "SELECT COUNT(*) FROM TEST WHERE ID<100");
         c1.commit();
-        assertResult(s2, "SELECT COUNT(*) FROM TEST WHERE ID<100", "1");
-        assertResult(s2, "SELECT COUNT(*) FROM TEST WHERE ID<100", "1");
+        assertResult("1", s2, "SELECT COUNT(*) FROM TEST WHERE ID<100");
+        assertResult("1", s2, "SELECT COUNT(*) FROM TEST WHERE ID<100");
         s1.execute("DROP TABLE TEST");
         c1.commit();
         c2.commit();
@@ -362,10 +362,10 @@ public class TestMvcc1 extends TestBase {
         s1.execute("CREATE TABLE TEST(ID INT, NAME VARCHAR, PRIMARY KEY(ID, NAME))");
         s1.execute("INSERT INTO TEST VALUES(1, 'Hello')");
         c1.commit();
-        assertResult(s2, "SELECT NAME FROM TEST WHERE ID=1", "Hello");
+        assertResult("Hello", s2, "SELECT NAME FROM TEST WHERE ID=1");
         s1.execute("UPDATE TEST SET NAME = 'Hallo' WHERE ID=1");
-        assertResult(s2, "SELECT NAME FROM TEST WHERE ID=1", "Hello");
-        assertResult(s1, "SELECT NAME FROM TEST WHERE ID=1", "Hallo");
+        assertResult("Hello", s2, "SELECT NAME FROM TEST WHERE ID=1");
+        assertResult("Hallo", s1, "SELECT NAME FROM TEST WHERE ID=1");
         s1.execute("DROP TABLE TEST");
         c1.commit();
         c2.commit();
@@ -382,20 +382,20 @@ public class TestMvcc1 extends TestBase {
         }
         ResultSet rs = s1.executeQuery("select * from test order by id");
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(1, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getString(2), "World");
+        assertEquals(2, rs.getInt(1));
+        assertEquals("World", rs.getString(2));
         assertFalse(rs.next());
 
         rs = s2.executeQuery("select * from test order by id");
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(1, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         assertTrue(rs.next());
-        assertEquals(rs.getInt(1), 2);
-        assertEquals(rs.getString(2), "World");
+        assertEquals(2, rs.getInt(1));
+        assertEquals("World", rs.getString(2));
         assertFalse(rs.next());
         s1.execute("drop table test");
         c1.commit();

h2/src/test/org/h2/test/server/TestNestedLoop.java

@@ -60,13 +60,13 @@ public class TestNestedLoop extends TestBase {
             int id = rs.getInt(1);
             ResultSet rs2 = stat2.executeQuery("select * from test where id=" + id);
             while (rs2.next()) {
-                assertEquals(rs2.getInt(1), id);
-                assertEquals(rs2.getString(2), "Hello World");
+                assertEquals(id, rs2.getInt(1));
+                assertEquals("Hello World", rs2.getString(2));
             }
             rs2 = stat2.executeQuery("select * from test where id=" + id);
             while (rs2.next()) {
-                assertEquals(rs2.getInt(1), id);
-                assertEquals(rs2.getString(2), "Hello World");
+                assertEquals(id, rs2.getInt(1));
+                assertEquals("Hello World", rs2.getString(2));
             }
         }
         conn.close();

h2/src/test/org/h2/test/synth/TestKill.java

@@ -125,7 +125,7 @@ public class TestKill extends TestBase {
             ResultSet rs2 = prep.executeQuery();
             rs2.next();
             int sumLog = rs2.getInt(1);
-            assertEquals(sumLog, sum);
+            assertEquals(sum, sumLog);
             trace("account=" + account + " sum=" + sum);
         }
         PreparedStatement p1 = conn.prepareStatement("SELECT * FROM TEST_A WHERE ID=?");

h2/src/test/org/h2/test/synth/TestTimer.java

@@ -80,7 +80,7 @@ public class TestTimer extends TestBase {
                 rs = stat.executeQuery("SELECT COUNT(*) FROM TEST");
                 rs.next();
                 int c = rs.getInt(1);
-                assertEquals(c, count);
+                assertEquals(count, c);
                 long time = System.currentTimeMillis();
                 if (time > start + 5000) {
                     println("rows: " + count);

h2/src/test/org/h2/test/synth/thread/TestMultiOrder.java

@@ -136,17 +136,17 @@ public class TestMultiOrder extends TestMultiThread {
         conn = base.getConnection();
         ResultSet rs = conn.createStatement().executeQuery("select count(*) from customer");
         rs.next();
-        base.assertEquals(rs.getInt(1), customerCount);
+        base.assertEquals(customerCount, rs.getInt(1));
         // System.out.println("customers: " + rs.getInt(1));
 
         rs = conn.createStatement().executeQuery("select count(*) from orders");
         rs.next();
-        base.assertEquals(rs.getInt(1), orderCount);
+        base.assertEquals(orderCount, rs.getInt(1));
         // System.out.println("orders: " + rs.getInt(1));
 
         rs = conn.createStatement().executeQuery("select count(*) from orderLine");
         rs.next();
-        base.assertEquals(rs.getInt(1), orderLineCount);
+        base.assertEquals(orderLineCount, rs.getInt(1));
         // System.out.println("orderLines: " + rs.getInt(1));
 
         conn.close();

h2/src/test/org/h2/test/unit/TestBitField.java

@@ -118,9 +118,9 @@ public class TestBitField extends TestBase {
                     set.clear(idx);
                 }
             } else {
-                assertEquals(bits.get(idx), set.get(idx));
-                assertEquals(bits.nextClearBit(idx), set.nextClearBit(idx));
-                assertEquals(bits.nextSetBit(idx), set.nextSetBit(idx));
+                assertEquals(set.get(idx), bits.get(idx));
+                assertEquals(set.nextClearBit(idx), bits.nextClearBit(idx));
+                assertEquals(set.nextSetBit(idx), bits.nextSetBit(idx));
             }
         }
     }
@@ -164,7 +164,7 @@ public class TestBitField extends TestBase {
             set.set(offset, offset + len, val);
             bits.setRange(offset, len, val);
             for (int j = 0; j < total; j++) {
-                assertEquals(bits.get(j), set.get(j));
+                assertEquals(set.get(j), bits.get(j));
             }
         }
     }

h2/src/test/org/h2/test/unit/TestCompress.java

@@ -80,7 +80,7 @@ public class TestCompress extends TestBase {
             for (String a : new String[] { "LZF", "Deflate", "No" }) {
                 byte[] out = utils.compress(buff, a);
                 byte[] test = utils.expand(out);
-                assertEquals(test.length, buff.length);
+                assertEquals(buff.length, test.length);
                 assertEquals(buff, test);
             }
         }

h2/src/test/org/h2/test/unit/TestDataPage.java

@@ -51,7 +51,7 @@ public class TestDataPage extends TestBase implements DataHandler {
         String s = new String(data);
         page.writeString(s);
         int len = page.length();
-        assertEquals(page.getStringLen(s), len);
+        assertEquals(len, page.getStringLen(s));
         page.reset();
         assertEquals(s, page.readString());
         page.reset();

h2/src/test/org/h2/test/unit/TestFileLock.java

@@ -84,7 +84,7 @@ public class TestFileLock extends TestBase implements Runnable {
         for (int i = 0; i < threadCount; i++) {
             threads[i].join();
         }
-        assertEquals(locks, 0);
+        assertEquals(0, locks);
     }
 
     public void run() {

h2/src/test/org/h2/test/unit/TestFileSystem.java

@@ -146,11 +146,11 @@ public class TestFileSystem extends TestBase {
         long lastMod = fs.getLastModified(fsBase + "/test");
         if (lastMod < time - 1999) {
             // at most 2 seconds difference
-            assertEquals(lastMod, time);
+            assertEquals(time, lastMod);
         }
-        assertEquals(fs.length(fsBase + "/test"), 10000);
+        assertEquals(10000, fs.length(fsBase + "/test"));
         String[] list = fs.listFiles(fsBase);
-        assertEquals(list.length, 1);
+        assertEquals(1, list.length);
         assertTrue(list[0].endsWith("test"));
 
         fs.copy(fsBase + "/test", fsBase + "/test3");
@@ -279,10 +279,10 @@ public class TestFileSystem extends TestBase {
         out.close();
         InputStream in = fs.openFileInputStream(s);
         for (int i = 0; i < 10000; i++) {
-            assertEquals(in.read(), 0);
+            assertEquals(0, in.read());
         }
-        assertEquals(in.read(), 1);
-        assertEquals(in.read(), -1);
+        assertEquals(1, in.read());
+        assertEquals(-1, in.read());
         in.close();
         out.close();
     }

h2/src/test/org/h2/test/unit/TestFtp.java

@@ -41,11 +41,11 @@ public class TestFtp extends TestBase implements FtpEventListener {
         client.login("sa", "sa");
         client.makeDirectory("test");
         client.changeWorkingDirectory("test");
-        assertEquals(lastEvent.getCommand(), "CWD");
+        assertEquals("CWD", lastEvent.getCommand());
         client.makeDirectory("hello");
         client.changeWorkingDirectory("hello");
         client.changeDirectoryUp();
-        assertEquals(lastEvent.getCommand(), "CDUP");
+        assertEquals("CDUP", lastEvent.getCommand());
         client.nameList("hello");
         client.removeDirectory("hello");
         client.close();

h2/src/test/org/h2/test/unit/TestIntArray.java

@@ -73,11 +73,11 @@ public class TestIntArray extends TestBase {
                 test = sort(test);
                 int a = array.findNextIndexSorted(v);
                 int b = findNextValueIndex(test, v);
-                assertEquals(a, b);
+                assertEquals(b, a);
                 break;
             case 4:
                 if (test.length > idx) {
-                    assertEquals(array.get(idx), get(test, idx));
+                    assertEquals(get(test, idx), array.get(idx));
                 }
                 break;
             case 5:
@@ -96,11 +96,11 @@ public class TestIntArray extends TestBase {
                 test = set(test, idx, v);
                 break;
             case 8:
-                assertEquals(array.size(), test.length);
+                assertEquals(test.length, array.size());
                 break;
             default:
             }
-            assertEquals(array.size(), test.length);
+            assertEquals(test.length, array.size());
             for (int j = 0; j < test.length; j++) {
                 assertEquals(test[j], array.get(j));
             }

h2/src/test/org/h2/test/unit/TestPgServer.java

@@ -69,34 +69,34 @@ public class TestPgServer extends TestBase {
         ResultSet rs = stat.executeQuery("select * from test");
         rs.next();
         prep.close();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(1, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         assertFalse(rs.next());
         prep = conn.prepareStatement("select * from test where id = ? and name = ?");
         prep.setInt(1, 1);
         prep.setString(2, "Hello");
         rs = prep.executeQuery();
         rs.next();
-        assertEquals(rs.getInt(1), 1);
-        assertEquals(rs.getString(2), "Hello");
+        assertEquals(1, rs.getInt(1));
+        assertEquals("Hello", rs.getString(2));
         assertFalse(rs.next());
         rs.close();
         DatabaseMetaData dbMeta = conn.getMetaData();
         rs = dbMeta.getTables(null, null, "TEST", null);
         rs.next();
-        assertEquals(rs.getString("TABLE_NAME"), "TEST");
+        assertEquals("TEST", rs.getString("TABLE_NAME"));
         assertFalse(rs.next());
         rs = dbMeta.getColumns(null, null, "TEST", null);
         rs.next();
-        assertEquals(rs.getString("COLUMN_NAME"), "ID");
+        assertEquals("ID", rs.getString("COLUMN_NAME"));
         rs.next();
-        assertEquals(rs.getString("COLUMN_NAME"), "NAME");
+        assertEquals("NAME", rs.getString("COLUMN_NAME"));
         assertFalse(rs.next());
         rs = dbMeta.getIndexInfo(null, null, "TEST", false, false);
         rs.next();
-        assertEquals(rs.getString("TABLE_NAME"), "TEST");
+        assertEquals("TEST", rs.getString("TABLE_NAME"));
         rs.next();
-        assertEquals(rs.getString("TABLE_NAME"), "TEST");
+        assertEquals("TEST", rs.getString("TABLE_NAME"));
         assertFalse(rs.next());
         rs = stat.executeQuery("select version(), pg_postmaster_start_time(), current_schema()");
         rs.next();

h2/src/test/org/h2/test/unit/TestReader.java

@@ -37,7 +37,7 @@ public class TestReader extends TestBase {
         InputStream in2 = new ByteArrayInputStream(buff);
         Reader r2 = IOUtils.getReader(in2);
         String s2 = IOUtils.readStringAndClose(r2, Integer.MAX_VALUE);
-        assertEquals(s2, "\u00ef\u00f6\u00fc");
+        assertEquals(s, s2);
     }
 
 }

h2/src/test/org/h2/test/unit/TestSampleApps.java

@@ -88,10 +88,10 @@ public class TestSampleApps extends TestBase {
         if (expected.endsWith("*")) {
             expected = expected.substring(0, expected.length() - 1);
             if (!s.startsWith(expected)) {
-                assertEquals(s.trim(), expected.trim());
+                assertEquals(expected.trim(), s.trim());
             }
         } else {
-            assertEquals(s.trim(), expected.trim());
+            assertEquals(expected.trim(), s.trim());
         }
     }
 }

h2/src/test/org/h2/test/unit/TestSecurity.java

@@ -42,7 +42,7 @@ public class TestSecurity extends TestBase {
     private String getHashString(SHA256 sha, byte[] data) {
         byte[] result = sha.getHash(data, true);
         if (data.length > 0) {
-            assertEquals(data[0], 0);
+            assertEquals(0, data[0]);
         }
         return ByteUtils.convertBytesToString(result);
     }

h2/src/test/org/h2/test/unit/TestValue.java

@@ -68,9 +68,9 @@ public class TestValue extends TestBase {
             minLow &= uuid.getLow();
         }
         ValueUuid max = ValueUuid.get(maxHigh, maxLow);
-        assertEquals(max.getString(), "ffffffff-ffff-4fff-bfff-ffffffffffff");
+        assertEquals("ffffffff-ffff-4fff-bfff-ffffffffffff", max.getString());
         ValueUuid min = ValueUuid.get(minHigh, minLow);
-        assertEquals(min.getString(), "00000000-0000-4000-8000-000000000000");
+        assertEquals("00000000-0000-4000-8000-000000000000", min.getString());
     }
 
 }