diff --git a/persistence-modules/core-java-persistence/src/main/java/com/baeldung/jdbc/Employee.java b/persistence-modules/core-java-persistence/src/main/java/com/baeldung/jdbc/Employee.java
index 8f3fce0378..88af4902b5 100644
--- a/persistence-modules/core-java-persistence/src/main/java/com/baeldung/jdbc/Employee.java
+++ b/persistence-modules/core-java-persistence/src/main/java/com/baeldung/jdbc/Employee.java
@@ -1,55 +1,71 @@
 package com.baeldung.jdbc;
 
+import java.util.Objects;
+
 public class Employee {
-    private int id;
-    private String name;
-    private String position;
-    private double salary;
+	private int id;
+	private String name;
+	private String position;
+	private double salary;
 
-    public Employee() {
-    }
+	public Employee() {
+	}
 
-    public Employee(int id, String name, double salary, String position) {
-        this.id = id;
-        this.name = name;
-        this.salary = salary;
-        this.position = position;
-    }
+	public Employee(int id, String name, double salary, String position) {
+		this.id = id;
+		this.name = name;
+		this.salary = salary;
+		this.position = position;
+	}
 
-    public int getId() {
-        return id;
-    }
+	public int getId() {
+		return id;
+	}
 
-    public void setId(int id) {
-        this.id = id;
-    }
+	public void setId(int id) {
+		this.id = id;
+	}
 
-    public String getName() {
-        return name;
-    }
+	public String getName() {
+		return name;
+	}
 
-    public void setName(String name) {
-        this.name = name;
-    }
+	public void setName(String name) {
+		this.name = name;
+	}
 
-    public double getSalary() {
-        return salary;
-    }
+	public double getSalary() {
+		return salary;
+	}
 
-    public void setSalary(double salary) {
-        this.salary = salary;
-    }
+	public void setSalary(double salary) {
+		this.salary = salary;
+	}
 
-    public String getPosition() {
-        return position;
-    }
+	public String getPosition() {
+		return position;
+	}
+
+	public void setPosition(String position) {
+		this.position = position;
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(id, name, position, salary);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Employee other = (Employee) obj;
+		return id == other.id && Objects.equals(name, other.name) && Objects.equals(position, other.position)
+				&& Double.doubleToLongBits(salary) == Double.doubleToLongBits(other.salary);
+	}
 
-    public void setPosition(String position) {
-        this.position = position;
-    }
-    
-    @Override
-    public boolean equals(Object obj) {
-        return this.getId() == ((Employee) obj).getId();
-    }
 }
diff --git a/persistence-modules/core-java-persistence/src/test/java/com/baeldung/jdbc/ResultSetLiveTest.java b/persistence-modules/core-java-persistence/src/test/java/com/baeldung/jdbc/ResultSetLiveTest.java
index 369d5e9222..553c7f9919 100644
--- a/persistence-modules/core-java-persistence/src/test/java/com/baeldung/jdbc/ResultSetLiveTest.java
+++ b/persistence-modules/core-java-persistence/src/test/java/com/baeldung/jdbc/ResultSetLiveTest.java
@@ -23,303 +23,326 @@ import org.junit.runners.MethodSorters;
 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
 public class ResultSetLiveTest {
 
-    private static final Logger logger = Logger.getLogger(ResultSetLiveTest.class);
+	private static final Logger logger = Logger.getLogger(ResultSetLiveTest.class);
 
-    private final Employee expectedEmployee1 = new Employee(1, "John", 1000.0, "Developer");
+	private final Employee expectedEmployee1 = new Employee(1, "John", 1000.0, "Developer");
 
-    private final Employee updatedEmployee1 = new Employee(1, "John", 1100.0, "Developer");
+	private final Employee updatedEmployee1 = new Employee(1, "John", 1100.0, "Developer");
 
-    private final Employee expectedEmployee2 = new Employee(2, "Chris", 925.0, "DBA");
+	private final Employee expectedEmployee2 = new Employee(2, "Chris", 925.0, "DBA");
 
-    private final int rowCount = 2;
+	private final int rowCount = 2;
 
-    private static Connection dbConnection;
+	private static Connection dbConnection;
 
-    @BeforeClass
-    public static void setup() throws ClassNotFoundException, SQLException {
-        Class.forName("com.mysql.cj.jdbc.Driver");
-        dbConnection = DriverManager.getConnection("jdbc:mysql://localhost:3306/myDB?noAccessToProcedureBodies=true", "user1", "pass");
-        String tableSql = "CREATE TABLE IF NOT EXISTS employees (emp_id int PRIMARY KEY AUTO_INCREMENT, name varchar(30), position varchar(30), salary double)";
-        try (Statement stmt = dbConnection.createStatement()) {
-            stmt.execute(tableSql);
-            try (PreparedStatement pstmt = dbConnection.prepareStatement("INSERT INTO employees(name, position, salary) values ('John', 'Developer', 1000.0)")) {
-                pstmt.executeUpdate();
-            }
-        }
-    }
+	@BeforeClass
+	public static void setup() throws ClassNotFoundException, SQLException {
+		Class.forName("com.mysql.cj.jdbc.Driver");
+		dbConnection = DriverManager.getConnection("jdbc:mysql://localhost:3306/myDB?noAccessToProcedureBodies=true",
+				"user1", "pass");
+		String tableSql = "CREATE TABLE IF NOT EXISTS employees (emp_id int PRIMARY KEY AUTO_INCREMENT, name varchar(30), position varchar(30), salary double)";
+		try (Statement stmt = dbConnection.createStatement()) {
+			stmt.execute(tableSql);
+			try (PreparedStatement pstmt = dbConnection.prepareStatement(
+					"INSERT INTO employees(name, position, salary) values ('John', 'Developer', 1000.0)")) {
+				pstmt.executeUpdate();
+			}
+		}
+	}
 
-    @Test
-    public void givenDbConnectionA_whenARetreiveByColumnNames_thenCorrect() throws SQLException {
-        Employee employee = null;
-        try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees"); ResultSet rs = pstmt.executeQuery()) {
-            while (rs.next()) {
-                String name = rs.getString("name");
-                Integer empId = rs.getInt("emp_id");
-                Double salary = rs.getDouble("salary");
-                String position = rs.getString("position");
-                employee = new Employee(empId, name, salary, position);
-            }
-        }
+	@Test
+	public void givenDbConnectionA_whenARetreiveByColumnNames_thenCorrect() throws SQLException {
+		Employee employee = null;
+		try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees");
+				ResultSet rs = pstmt.executeQuery()) {
+			while (rs.next()) {
+				String name = rs.getString("name");
+				Integer empId = rs.getInt("emp_id");
+				Double salary = rs.getDouble("salary");
+				String position = rs.getString("position");
+				employee = new Employee(empId, name, salary, position);
+			}
+		}
 
-        assertEquals("Employee information retreived by column names.", expectedEmployee1, employee);
-    }
+		assertEquals("Employee information retreived by column names.", expectedEmployee1, employee);
+	}
 
-    @Test
-    public void givenDbConnectionB_whenBRetreiveByColumnIds_thenCorrect() throws SQLException {
-        Employee employee = null;
-        try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees"); ResultSet rs = pstmt.executeQuery()) {
-            while (rs.next()) {
-                Integer empId = rs.getInt(1);
-                String name = rs.getString(2);
-                String position = rs.getString(3);
-                Double salary = rs.getDouble(4);
-                employee = new Employee(empId, name, salary, position);
-            }
-        }
+	@Test
+	public void givenDbConnectionB_whenBRetreiveByColumnIds_thenCorrect() throws SQLException {
+		Employee employee = null;
+		try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees");
+				ResultSet rs = pstmt.executeQuery()) {
+			while (rs.next()) {
+				Integer empId = rs.getInt(1);
+				String name = rs.getString(2);
+				String position = rs.getString(3);
+				Double salary = rs.getDouble(4);
+				employee = new Employee(empId, name, salary, position);
+			}
+		}
 
-        assertEquals("Employee information retreived by column ids.", employee, expectedEmployee1);
-    }
+		assertEquals("Employee information retreived by column ids.", expectedEmployee1, employee);
+	}
 
-    @Test
-    public void givenDbConnectionD_whenInsertRow_thenCorrect() throws SQLException {
-        int rowCount = 0;
-        try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
-            rs.moveToInsertRow();
-            rs.updateString("name", "Venkat");
-            rs.updateString("position", "DBA");
-            rs.updateDouble("salary", 925.0);
-            rs.insertRow();
-            rs.moveToCurrentRow();
-            rs.last();
-            rowCount = rs.getRow();
-        }
+	@Test
+	public void givenDbConnectionD_whenInsertRow_thenCorrect() throws SQLException {
+		int rowCount = 0;
+		try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees",
+				ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
+			rs.moveToInsertRow();
+			rs.updateString("name", "Venkat");
+			rs.updateString("position", "DBA");
+			rs.updateDouble("salary", 925.0);
+			rs.insertRow();
+			rs.moveToCurrentRow();
+			rs.last();
+			rowCount = rs.getRow();
+		}
 
-        assertEquals("Row Count after inserting a row", rowCount, 2);
-    }
+		assertEquals("Row Count after inserting a row", 2, rowCount);
+	}
 
-    private Employee populateResultSet(ResultSet rs) throws SQLException {
-        Employee employee;
-        String name = rs.getString("name");
-        Integer empId = rs.getInt("emp_id");
-        Double salary = rs.getDouble("salary");
-        String position = rs.getString("position");
-        employee = new Employee(empId, name, salary, position);
-        return employee;
-    }
+	private Employee populateResultSet(ResultSet rs) throws SQLException {
+		Employee employee;
+		String name = rs.getString("name");
+		Integer empId = rs.getInt("emp_id");
+		Double salary = rs.getDouble("salary");
+		String position = rs.getString("position");
+		employee = new Employee(empId, name, salary, position);
+		return employee;
+	}
 
-    @Test
-    public void givenDbConnectionE_whenRowCount_thenCorrect() throws SQLException {
-        int numOfRows = 0;
-        try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
-            rs.last();
-            numOfRows = rs.getRow();
-        }
+	@Test
+	public void givenDbConnectionE_whenRowCount_thenCorrect() throws SQLException {
+		int numOfRows = 0;
+		try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees",
+				ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
+			rs.last();
+			numOfRows = rs.getRow();
+		}
 
-        assertEquals("Num of rows", numOfRows, rowCount);
-    }
+		assertEquals("Num of rows", rowCount, numOfRows);
+	}
 
-    @Test
-    public void givenDbConnectionG_whenAbsoluteNavigation_thenCorrect() throws SQLException {
-        Employee secondEmployee = null;
-        try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
-            rs.absolute(2);
-            secondEmployee = populateResultSet(rs);
-        }
+	@Test
+	public void givenDbConnectionG_whenAbsoluteNavigation_thenCorrect() throws SQLException {
+		Employee secondEmployee = null;
+		try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees",
+				ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
+			rs.absolute(2);
+			secondEmployee = populateResultSet(rs);
+		}
 
-        assertEquals("Absolute navigation", secondEmployee, expectedEmployee2);
-    }
+		assertEquals("Absolute navigation", expectedEmployee2, secondEmployee);
+	}
 
-    @Test
-    public void givenDbConnectionH_whenLastNavigation_thenCorrect() throws SQLException {
-        Employee secondEmployee = null;
-        try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
-            rs.last();
-            secondEmployee = populateResultSet(rs);
-        }
+	@Test
+	public void givenDbConnectionH_whenLastNavigation_thenCorrect() throws SQLException {
+		Employee secondEmployee = null;
+		try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees",
+				ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
+			rs.last();
+			secondEmployee = populateResultSet(rs);
+		}
 
-        assertEquals("Using Last", secondEmployee, expectedEmployee2);
-    }
+		assertEquals("Using Last", expectedEmployee2, secondEmployee);
+	}
 
-    @Test
-    public void givenDbConnectionI_whenNavigation_thenCorrect() throws SQLException {
-        Employee firstEmployee = null;
-        try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
-            while (rs.next()) {
-                Employee employee = populateResultSet(rs);
-            }
-            rs.beforeFirst();
-            while (rs.next()) {
-                Employee employee = populateResultSet(rs);
-            }
-            rs.first();
-            while (rs.next()) {
-                Employee employee = populateResultSet(rs);
-            }
-            while (rs.previous()) {
-                Employee employee = populateResultSet(rs);
-            }
-            rs.afterLast();
-            while (rs.previous()) {
-                Employee employee = populateResultSet(rs);
-            }
-            rs.last();
-            while (rs.previous()) {
-                firstEmployee = populateResultSet(rs);
-            }
-        }
+	@Test
+	public void givenDbConnectionI_whenNavigation_thenCorrect() throws SQLException {
+		Employee firstEmployee = null;
+		try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees",
+				ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
+			while (rs.next()) {
+				Employee employee = populateResultSet(rs);
+			}
+			rs.beforeFirst();
+			while (rs.next()) {
+				Employee employee = populateResultSet(rs);
+			}
+			rs.first();
+			while (rs.next()) {
+				Employee employee = populateResultSet(rs);
+			}
+			while (rs.previous()) {
+				Employee employee = populateResultSet(rs);
+			}
+			rs.afterLast();
+			while (rs.previous()) {
+				Employee employee = populateResultSet(rs);
+			}
+			rs.last();
+			while (rs.previous()) {
+				firstEmployee = populateResultSet(rs);
+			}
+		}
 
-        assertEquals("Several Navigation Options", firstEmployee, updatedEmployee1);
-    }
+		assertEquals("Several Navigation Options", updatedEmployee1, firstEmployee);
+	}
 
-    @Test
-    public void givenDbConnectionJ_whenClosedCursor_thenCorrect() throws SQLException {
-        int numOfRows = 0;
-        dbConnection.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
-        try (Statement pstmt = dbConnection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.CLOSE_CURSORS_AT_COMMIT)) {
-            dbConnection.setAutoCommit(false);
-            pstmt.executeUpdate("INSERT INTO employees (name, salary,position) VALUES ('Chris',2100.0,'Manager')");
-            ResultSet rs = pstmt.executeQuery("select * from employees");
-            dbConnection.commit();
-            while (rs.next()) {
-                Employee employee = populateResultSet(rs);
-            }
-            rs.last();
-            numOfRows = rs.getRow();
-        }
+	@Test
+	public void givenDbConnectionJ_whenClosedCursor_thenCorrect() throws SQLException {
+		int numOfRows = 0;
+		dbConnection.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
+		try (Statement pstmt = dbConnection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE,
+				ResultSet.CLOSE_CURSORS_AT_COMMIT)) {
+			dbConnection.setAutoCommit(false);
+			pstmt.executeUpdate("INSERT INTO employees (name, salary,position) VALUES ('Chris',2100.0,'Manager')");
+			ResultSet rs = pstmt.executeQuery("select * from employees");
+			dbConnection.commit();
+			while (rs.next()) {
+				Employee employee = populateResultSet(rs);
+			}
+			rs.last();
+			numOfRows = rs.getRow();
+		}
 
-        assertEquals("Inserted using close cursor after commit", numOfRows, 3);
-    }
+		assertEquals("Inserted using close cursor after commit", 3, numOfRows);
+	}
 
-    @Test
-    public void givenDbConnectionK_whenUpdate_thenCorrect() throws SQLException {
-        int numOfRows = 0;
-        try (Statement pstmt = dbConnection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.HOLD_CURSORS_OVER_COMMIT)) {
-            dbConnection.setAutoCommit(false);
-            pstmt.executeUpdate("INSERT INTO employees (name, salary,position) VALUES ('Michael',1200.0,'Consultant')");
-            ResultSet rs = pstmt.executeQuery("select * from employees");
-            dbConnection.commit();
-            while (rs.next()) {
-                Employee employee = populateResultSet(rs);
-            }
-            rs.last();
-            numOfRows = rs.getRow();
-        }
+	@Test
+	public void givenDbConnectionK_whenUpdate_thenCorrect() throws SQLException {
+		int numOfRows = 0;
+		try (Statement pstmt = dbConnection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE,
+				ResultSet.HOLD_CURSORS_OVER_COMMIT)) {
+			dbConnection.setAutoCommit(false);
+			pstmt.executeUpdate("INSERT INTO employees (name, salary,position) VALUES ('Michael',1200.0,'Consultant')");
+			ResultSet rs = pstmt.executeQuery("select * from employees");
+			dbConnection.commit();
+			while (rs.next()) {
+				Employee employee = populateResultSet(rs);
+			}
+			rs.last();
+			numOfRows = rs.getRow();
+		}
 
-        assertEquals("Inserted using hold cursor after commit", numOfRows, 4);
-    }
+		assertEquals("Inserted using hold cursor after commit", 4, numOfRows);
+	}
 
-    @Test
-    public void givenDbConnectionL_whenDelete_thenCorrect() throws SQLException {
-        int numOfRows = 0;
-        try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
-            rs.absolute(3);
-            rs.deleteRow();
-            rs.last();
-            numOfRows = rs.getRow();
-        }
+	@Test
+	public void givenDbConnectionL_whenDelete_thenCorrect() throws SQLException {
+		int numOfRows = 0;
+		try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees",
+				ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
+			rs.absolute(3);
+			rs.deleteRow();
+			rs.last();
+			numOfRows = rs.getRow();
+		}
 
-        assertEquals("Deleted row", numOfRows, 3);
-    }
+		assertEquals("Deleted row", 3, numOfRows);
+	}
 
-    @Test
-    public void givenDbConnectionC_whenUpdate_thenCorrect() throws SQLException {
-        Employee employee = null;
-        try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
-            while (rs.next()) {
-                rs.updateDouble("salary", 1100.0);
-                rs.updateRow();
-                rs.refreshRow();
-                String name = rs.getString("name");
-                Integer empId = rs.getInt("emp_id");
-                Double salary = rs.getDouble("salary");
-                String position = rs.getString("position");
-                employee = new Employee(empId, name, salary, position);
-            }
-        }
+	@Test
+	public void givenDbConnectionC_whenUpdate_thenCorrect() throws SQLException {
+		Employee employee = null;
+		try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees",
+				ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
+			while (rs.next()) {
+				rs.updateDouble("salary", 1100.0);
+				rs.updateRow();
+				rs.refreshRow();
+				String name = rs.getString("name");
+				Integer empId = rs.getInt("emp_id");
+				Double salary = rs.getDouble("salary");
+				String position = rs.getString("position");
+				employee = new Employee(empId, name, salary, position);
+			}
+		}
 
-        assertEquals("Employee information updated successfully.", employee, updatedEmployee1);
-    }
+		assertEquals("Employee information updated successfully.", updatedEmployee1, employee);
+	}
 
-    @Test
-    public void givenDbConnectionE_whenDBMetaInfo_thenCorrect() throws SQLException {
-        DatabaseMetaData dbmd = dbConnection.getMetaData();
-        boolean supportsTypeForward = dbmd.supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY);
-        boolean supportsTypeScrollSensitive = dbmd.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
-        boolean supportsTypeScrollInSensitive = dbmd.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE);
-        boolean supportsCloseCursorsAtCommit = dbmd.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
-        boolean supportsHoldCursorsAtCommit = dbmd.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
-        boolean concurrency4TypeFwdNConcurReadOnly = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
-        boolean concurrency4TypeFwdNConcurUpdatable = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
-        boolean concurrency4TypeScrollInSensitiveNConcurUpdatable = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
-        boolean concurrency4TypeScrollInSensitiveNConcurReadOnly = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
-        boolean concurrency4TypeScrollSensitiveNConcurUpdatable = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
-        boolean concurrency4TypeScrollSensitiveNConcurReadOnly = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
-        int rsHoldability = dbmd.getResultSetHoldability();
+	@Test
+	public void givenDbConnectionE_whenDBMetaInfo_thenCorrect() throws SQLException {
+		DatabaseMetaData dbmd = dbConnection.getMetaData();
+		boolean supportsTypeForward = dbmd.supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY);
+		boolean supportsTypeScrollSensitive = dbmd.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
+		boolean supportsTypeScrollInSensitive = dbmd.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE);
+		boolean supportsCloseCursorsAtCommit = dbmd.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
+		boolean supportsHoldCursorsAtCommit = dbmd.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
+		boolean concurrency4TypeFwdNConcurReadOnly = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY,
+				ResultSet.CONCUR_READ_ONLY);
+		boolean concurrency4TypeFwdNConcurUpdatable = dbmd.supportsResultSetConcurrency(ResultSet.TYPE_FORWARD_ONLY,
+				ResultSet.CONCUR_UPDATABLE);
+		boolean concurrency4TypeScrollInSensitiveNConcurUpdatable = dbmd
+				.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
+		boolean concurrency4TypeScrollInSensitiveNConcurReadOnly = dbmd
+				.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
+		boolean concurrency4TypeScrollSensitiveNConcurUpdatable = dbmd
+				.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
+		boolean concurrency4TypeScrollSensitiveNConcurReadOnly = dbmd
+				.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
+		int rsHoldability = dbmd.getResultSetHoldability();
 
-        assertEquals("checking scroll sensitivity and concur updates : ", concurrency4TypeScrollInSensitiveNConcurUpdatable, true);
-    }
+		assertEquals("checking scroll sensitivity and concur updates : ", true,
+				concurrency4TypeScrollInSensitiveNConcurUpdatable);
+	}
 
-    @Test
-    public void givenDbConnectionF_whenRSMetaInfo_thenCorrect() throws SQLException {
-        int columnCount = 0;
-        try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
-            ResultSetMetaData metaData = rs.getMetaData();
-            columnCount = metaData.getColumnCount();
-            for (int i = 1; i <= columnCount; i++) {
-                String catalogName = metaData.getCatalogName(i);
-                String className = metaData.getColumnClassName(i);
-                String label = metaData.getColumnLabel(i);
-                String name = metaData.getColumnName(i);
-                String typeName = metaData.getColumnTypeName(i);
-                Integer type = metaData.getColumnType(i);
-                String tableName = metaData.getTableName(i);
-                String schemaName = metaData.getSchemaName(i);
-                boolean isAutoIncrement = metaData.isAutoIncrement(i);
-                boolean isCaseSensitive = metaData.isCaseSensitive(i);
-                boolean isCurrency = metaData.isCurrency(i);
-                boolean isDefiniteWritable = metaData.isDefinitelyWritable(i);
-                boolean isReadOnly = metaData.isReadOnly(i);
-                boolean isSearchable = metaData.isSearchable(i);
-                boolean isReadable = metaData.isReadOnly(i);
-                boolean isSigned = metaData.isSigned(i);
-                boolean isWritable = metaData.isWritable(i);
-                int nullable = metaData.isNullable(i);
-            }
-        }
+	@Test
+	public void givenDbConnectionF_whenRSMetaInfo_thenCorrect() throws SQLException {
+		int columnCount = 0;
+		try (PreparedStatement pstmt = dbConnection.prepareStatement("select * from employees",
+				ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet rs = pstmt.executeQuery()) {
+			ResultSetMetaData metaData = rs.getMetaData();
+			columnCount = metaData.getColumnCount();
+			for (int i = 1; i <= columnCount; i++) {
+				String catalogName = metaData.getCatalogName(i);
+				String className = metaData.getColumnClassName(i);
+				String label = metaData.getColumnLabel(i);
+				String name = metaData.getColumnName(i);
+				String typeName = metaData.getColumnTypeName(i);
+				Integer type = metaData.getColumnType(i);
+				String tableName = metaData.getTableName(i);
+				String schemaName = metaData.getSchemaName(i);
+				boolean isAutoIncrement = metaData.isAutoIncrement(i);
+				boolean isCaseSensitive = metaData.isCaseSensitive(i);
+				boolean isCurrency = metaData.isCurrency(i);
+				boolean isDefiniteWritable = metaData.isDefinitelyWritable(i);
+				boolean isReadOnly = metaData.isReadOnly(i);
+				boolean isSearchable = metaData.isSearchable(i);
+				boolean isReadable = metaData.isReadOnly(i);
+				boolean isSigned = metaData.isSigned(i);
+				boolean isWritable = metaData.isWritable(i);
+				int nullable = metaData.isNullable(i);
+			}
+		}
 
-        assertEquals("column count", columnCount, 4);
-    }
+		assertEquals("column count", 4, columnCount);
+	}
 
-    @Test
-    public void givenDbConnectionM_whenDelete_thenCorrect() throws SQLException {
-        PreparedStatement pstmt = null;
-        ResultSet rs = null;
-        List<Employee> listOfEmployees = new ArrayList<Employee>();
-        try {
-            pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
-            pstmt.setFetchSize(2);
-            rs = pstmt.executeQuery();
-            rs.setFetchSize(1);
-            while (rs.next()) {
-                Employee employee = populateResultSet(rs);
-                listOfEmployees.add(employee);
-            }
-        } catch (Exception e) {
-            throw e;
-        } finally {
-            if (rs != null)
-                rs.close();
-            if (pstmt != null)
-                pstmt.close();
-        }
-        
-        assertEquals(listOfEmployees.size(), 3);
-    }
+	@Test
+	public void givenDbConnectionM_whenDelete_thenCorrect() throws SQLException {
+		PreparedStatement pstmt = null;
+		ResultSet rs = null;
+		List<Employee> listOfEmployees = new ArrayList<Employee>();
+		try {
+			pstmt = dbConnection.prepareStatement("select * from employees", ResultSet.TYPE_FORWARD_ONLY,
+					ResultSet.CONCUR_READ_ONLY);
+			pstmt.setFetchSize(2);
+			rs = pstmt.executeQuery();
+			rs.setFetchSize(1);
+			while (rs.next()) {
+				Employee employee = populateResultSet(rs);
+				listOfEmployees.add(employee);
+			}
+		} catch (Exception e) {
+			throw e;
+		} finally {
+			if (rs != null)
+				rs.close();
+			if (pstmt != null)
+				pstmt.close();
+		}
 
-    @AfterClass
-    public static void closeConnection() throws SQLException {
-        PreparedStatement deleteStmt = dbConnection.prepareStatement("drop table employees", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
-        deleteStmt.execute();
-        dbConnection.close();
-    }
+		assertEquals(3, listOfEmployees.size());
+	}
+
+	@AfterClass
+	public static void closeConnection() throws SQLException {
+		PreparedStatement deleteStmt = dbConnection.prepareStatement("drop table employees",
+				ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
+		deleteStmt.execute();
+		dbConnection.close();
+	}
 }