db-torque-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tfisc...@apache.org
Subject svn commit: r1380467 - in /db/torque/torque4/trunk/torque-runtime/src: main/java/org/apache/torque/om/mapper/ test/java/org/apache/torque/om/mapper/
Date Tue, 04 Sep 2012 07:33:05 GMT
Author: tfischer
Date: Tue Sep  4 07:33:05 2012
New Revision: 1380467

URL: http://svn.apache.org/viewvc?rev=1380467&view=rev
Log:
Tests and fixes for Mapper classes

Added:
    db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/
    db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/BigDecimalMapperTest.java
    db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/CompositeMapperTest.java
    db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/DateMapperTest.java
    db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/IntegerMapperTest.java
    db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/LongMapperTest.java
    db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/ObjectListMapperTest.java
    db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/StringMapperTest.java
Modified:
    db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/BigDecimalMapper.java
    db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/DateMapper.java
    db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/IntegerMapper.java
    db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/LongMapper.java
    db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/ObjectListMapper.java

Modified: db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/BigDecimalMapper.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/BigDecimalMapper.java?rev=1380467&r1=1380466&r2=1380467&view=diff
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/BigDecimalMapper.java
(original)
+++ db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/BigDecimalMapper.java
Tue Sep  4 07:33:05 2012
@@ -68,7 +68,7 @@ public class BigDecimalMapper implements
         catch (SQLException e)
         {
             throw new TorqueException(
-                    "Result could not be mapped to a getBigDecimal",
+                    "Result could not be mapped to a BigDecimal",
                     e);
         }
     }

Modified: db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/DateMapper.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/DateMapper.java?rev=1380467&r1=1380466&r2=1380467&view=diff
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/DateMapper.java
(original)
+++ db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/DateMapper.java
Tue Sep  4 07:33:05 2012
@@ -71,15 +71,11 @@ public class DateMapper implements Recor
     {
         java.util.Date value = resultSet.getTimestamp(
             offset + internalOffset + 1);
-        if (resultSet.wasNull())
-        {
-            value = null;
-        }
         return value;
     }
     catch (SQLException e)
     {
-        throw new TorqueException(e);
+        throw new TorqueException("Result could not be mapped to a Date", e);
     }
   }
 }

Modified: db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/IntegerMapper.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/IntegerMapper.java?rev=1380467&r1=1380466&r2=1380467&view=diff
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/IntegerMapper.java
(original)
+++ db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/IntegerMapper.java
Tue Sep  4 07:33:05 2012
@@ -62,8 +62,13 @@ public class IntegerMapper implements Re
     {
         try
         {
-            return Integer.valueOf(
+            Integer result = Integer.valueOf(
                     resultSet.getInt(rowOffset + internalOffset + 1));
+            if (result == 0 && resultSet.wasNull())
+            {
+                return null;
+            }
+            return result;
         }
         catch (SQLException e)
         {

Modified: db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/LongMapper.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/LongMapper.java?rev=1380467&r1=1380466&r2=1380467&view=diff
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/LongMapper.java
(original)
+++ db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/LongMapper.java
Tue Sep  4 07:33:05 2012
@@ -62,8 +62,13 @@ public class LongMapper implements Recor
     {
         try
         {
-            return Long.valueOf(
+            Long result = Long.valueOf(
                     resultSet.getLong(rowOffset + internalOffset + 1));
+            if (result == 0 && resultSet.wasNull())
+            {
+                return null;
+            }
+            return result;
         }
         catch (SQLException e)
         {

Modified: db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/ObjectListMapper.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/ObjectListMapper.java?rev=1380467&r1=1380466&r2=1380467&view=diff
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/ObjectListMapper.java
(original)
+++ db/torque/torque4/trunk/torque-runtime/src/main/java/org/apache/torque/om/mapper/ObjectListMapper.java
Tue Sep  4 07:33:05 2012
@@ -21,9 +21,9 @@ package org.apache.torque.om.mapper;
 
 import java.io.InputStream;
 import java.io.Reader;
-import java.lang.reflect.Array;
 import java.math.BigDecimal;
 import java.net.URL;
+import java.sql.Array;
 import java.sql.Blob;
 import java.sql.Clob;
 import java.sql.Date;
@@ -49,6 +49,12 @@ public class ObjectListMapper implements
     /** Serial Version UID. */
     private static final long serialVersionUID = 1L;
 
+    /** Zero value for byte. */
+    private static final byte ZERO_BYTE = 0;
+
+    /** Zero value for short. */
+    private static final short ZERO_SHORT = 0;
+
     /**
      * Contains the classes to which the columns are mapped.
      * The size of the list determines how many columns are read.
@@ -180,6 +186,11 @@ public class ObjectListMapper implements
                 else if (mapClass.equals(Byte.class))
                 {
                     columnValue = resultSet.getByte(columnIndex);
+                    if (Byte.valueOf(ZERO_BYTE).equals(columnValue)
+                            && resultSet.wasNull())
+                    {
+                        columnValue =  null;
+                    }
                 }
                 else if (mapClass.equals(byte[].class))
                 {
@@ -200,18 +211,38 @@ public class ObjectListMapper implements
                 else if (mapClass.equals(Double.class))
                 {
                     columnValue = resultSet.getDouble(columnIndex);
+                    if (Double.valueOf(0d).equals(columnValue)
+                            && resultSet.wasNull())
+                    {
+                        columnValue =  null;
+                    }
                 }
                 else if (mapClass.equals(Float.class))
                 {
                     columnValue = resultSet.getFloat(columnIndex);
+                    if (Float.valueOf(0f).equals(columnValue)
+                            && resultSet.wasNull())
+                    {
+                        columnValue =  null;
+                    }
                 }
                 else if (mapClass.equals(Integer.class))
                 {
                     columnValue = resultSet.getInt(columnIndex);
+                    if (Integer.valueOf(0).equals(columnValue)
+                            && resultSet.wasNull())
+                    {
+                        columnValue = null;
+                    }
                 }
                 else if (mapClass.equals(Long.class))
                 {
                     columnValue = resultSet.getLong(columnIndex);
+                    if (Long.valueOf(0L).equals(columnValue)
+                            && resultSet.wasNull())
+                    {
+                        columnValue =  null;
+                    }
                 }
                 else if (mapClass.equals(Object.class))
                 {
@@ -224,6 +255,11 @@ public class ObjectListMapper implements
                 else if (mapClass.equals(Short.class))
                 {
                     columnValue = resultSet.getShort(columnIndex);
+                    if (Short.valueOf(ZERO_SHORT).equals(columnValue)
+                            && resultSet.wasNull())
+                    {
+                        columnValue =  null;
+                    }
                 }
                 else if (mapClass.equals(String.class))
                 {

Added: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/BigDecimalMapperTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/BigDecimalMapperTest.java?rev=1380467&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/BigDecimalMapperTest.java
(added)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/BigDecimalMapperTest.java
Tue Sep  4 07:33:05 2012
@@ -0,0 +1,107 @@
+package org.apache.torque.om.mapper;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.math.BigDecimal;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.apache.torque.BaseTestCase;
+import org.apache.torque.TorqueException;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class BigDecimalMapperTest extends BaseTestCase
+{
+    /** Mock result set. */
+    @Mock
+    private ResultSet resultSet;
+
+    @Override
+    public void setUp() throws Exception
+    {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        when(resultSet.getBigDecimal(1)).thenReturn(null);
+        when(resultSet.getBigDecimal(2)).thenReturn(new BigDecimal(0));
+        when(resultSet.getBigDecimal(3)).thenReturn(new BigDecimal("123.456"));
+        when(resultSet.getBigDecimal(0)).thenThrow(
+                new SQLException("index must be >= 1"));
+    }
+
+    /**
+     * Tests the processRow method for a mapper without internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRow() throws Exception
+    {
+        // prepare
+        BigDecimalMapper mapper = new BigDecimalMapper();
+
+        // execute
+        BigDecimal result1 = mapper.processRow(resultSet, 0);
+        BigDecimal result2 = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(null, result1);
+        assertEquals(new BigDecimal(0), result2);
+        verify(resultSet).getBigDecimal(1);
+        verify(resultSet).getBigDecimal(2);
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method for a mapper with internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowInternalOffset() throws Exception
+    {
+        // prepare
+        BigDecimalMapper mapper = new BigDecimalMapper(1);
+
+        // execute
+        BigDecimal result1 = mapper.processRow(resultSet, 0);
+        BigDecimal result2 = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(new BigDecimal(0), result1);
+        assertEquals(new BigDecimal("123.456"), result2);
+        verify(resultSet).getBigDecimal(2);
+        verify(resultSet).getBigDecimal(3);
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method if the resultSet throws a SqlException.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowSqlException() throws Exception
+    {
+        // prepare
+        BigDecimalMapper mapper = new BigDecimalMapper();
+
+        // execute
+        try
+        {
+            mapper.processRow(resultSet, -1);
+            // verify 1
+            fail("Exception expected");
+        }
+        catch (TorqueException e)
+        {
+            // verify 2
+            assertEquals(
+                    "Result could not be mapped to a BigDecimal",
+                    e.getMessage());
+            assertEquals(SQLException.class, e.getCause().getClass());
+            assertEquals("index must be >= 1", e.getCause().getMessage());
+            verify(resultSet).getBigDecimal(0);
+            verifyNoMoreInteractions(resultSet);
+        }
+    }
+}

Added: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/CompositeMapperTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/CompositeMapperTest.java?rev=1380467&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/CompositeMapperTest.java
(added)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/CompositeMapperTest.java
Tue Sep  4 07:33:05 2012
@@ -0,0 +1,101 @@
+package org.apache.torque.om.mapper;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.sql.ResultSet;
+import java.util.List;
+
+import org.apache.torque.BaseTestCase;
+import org.apache.torque.TorqueException;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class CompositeMapperTest extends BaseTestCase
+{
+    /** System under test. */
+    CompositeMapper mapper;
+
+    /** Mock result set. */
+    @Mock
+    private ResultSet resultSet;
+
+    /** Mock delegate RecordMapper. */
+    @Mock
+    private RecordMapper recordMapper1;
+
+    /** Mock delegate RecordMapper. */
+    @Mock
+    private RecordMapper recordMapper2;
+
+    /** Mock delegate RecordMapper. */
+    @Mock
+    private RecordMapper recordMapper3;
+
+    @Override
+    public void setUp() throws Exception
+    {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        when(recordMapper1.processRow(resultSet, 3))
+            .thenReturn(null);
+        when(recordMapper2.processRow(resultSet, 4))
+            .thenReturn(new Integer(1));
+        when(recordMapper3.processRow(resultSet, 5))
+            .thenReturn(new Long(2));
+
+        mapper = new CompositeMapper();
+        mapper.addMapper(recordMapper1, 1);
+        mapper.addMapper(recordMapper2, 2);
+        mapper.addMapper(recordMapper3, 3);
+    }
+
+    /**
+     * Tests the processRow method for a mapper without internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRow() throws Exception
+    {
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 2);
+
+        // verify
+        assertEquals(3, result.size());
+        assertEquals(null, result.get(0));
+        assertEquals(new Integer(1), result.get(1));
+        assertEquals(new Long(2), result.get(2));
+        verify(recordMapper1).processRow(resultSet, 3);
+        verify(recordMapper2).processRow(resultSet, 4);
+        verify(recordMapper3).processRow(resultSet, 5);
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method if a delegate throws a SqlException.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowSqlException() throws Exception
+    {
+        // prepare
+        when(recordMapper1.processRow(resultSet, 1))
+            .thenThrow(new TorqueException("thrown by mock"));
+
+        // execute
+        try
+        {
+            mapper.processRow(resultSet, 0);
+            // verify 1
+            fail("Exception expected");
+        }
+        catch (TorqueException e)
+        {
+            // verify 2
+            assertEquals("thrown by mock", e.getMessage());
+            verify(recordMapper1).processRow(resultSet, 1);
+            verifyNoMoreInteractions(resultSet);
+        }
+    }
+}

Added: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/DateMapperTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/DateMapperTest.java?rev=1380467&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/DateMapperTest.java
(added)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/DateMapperTest.java
Tue Sep  4 07:33:05 2012
@@ -0,0 +1,109 @@
+package org.apache.torque.om.mapper;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Date;
+
+import org.apache.torque.BaseTestCase;
+import org.apache.torque.TorqueException;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class DateMapperTest extends BaseTestCase
+{
+    /** Mock result set. */
+    @Mock
+    private ResultSet resultSet;
+
+    @Override
+    public void setUp() throws Exception
+    {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        when(resultSet.getTimestamp(1)).thenReturn(null);
+        when(resultSet.getTimestamp(2)).thenReturn(
+                new java.sql.Timestamp(0));
+        when(resultSet.getTimestamp(3)).thenReturn(
+                new java.sql.Timestamp(123456));
+        when(resultSet.getTimestamp(0)).thenThrow(
+                new SQLException("index must be >= 1"));
+    }
+
+    /**
+     * Tests the processRow method for a mapper without internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRow() throws Exception
+    {
+        // prepare
+        DateMapper mapper = new DateMapper();
+
+        // execute
+        Date result1 = mapper.processRow(resultSet, 0);
+        Date result2 = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(null, result1);
+        assertEquals(new Date(0), result2);
+        verify(resultSet).getTimestamp(1);
+        verify(resultSet).getTimestamp(2);
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method for a mapper with internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowInternalOffset() throws Exception
+    {
+        // prepare
+        DateMapper mapper = new DateMapper(1);
+
+        // execute
+        Date result1 = mapper.processRow(resultSet, 0);
+        Date result2 = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(new Date(0), result1);
+        assertEquals(new Date(123456L), result2);
+        verify(resultSet).getTimestamp(2);
+        verify(resultSet).getTimestamp(3);
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method if the resultSet throws a SqlException.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowSqlException() throws Exception
+    {
+        // prepare
+        DateMapper mapper = new DateMapper();
+
+        // execute
+        try
+        {
+            mapper.processRow(resultSet, -1);
+            // verify 1
+            fail("Exception expected");
+        }
+        catch (TorqueException e)
+        {
+            // verify 2
+            assertEquals(
+                    "Result could not be mapped to a Date",
+                    e.getMessage());
+            assertEquals(SQLException.class, e.getCause().getClass());
+            assertEquals("index must be >= 1", e.getCause().getMessage());
+            verify(resultSet).getTimestamp(0);
+            verifyNoMoreInteractions(resultSet);
+        }
+    }
+}

Added: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/IntegerMapperTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/IntegerMapperTest.java?rev=1380467&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/IntegerMapperTest.java
(added)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/IntegerMapperTest.java
Tue Sep  4 07:33:05 2012
@@ -0,0 +1,109 @@
+package org.apache.torque.om.mapper;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.apache.torque.BaseTestCase;
+import org.apache.torque.TorqueException;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class IntegerMapperTest extends BaseTestCase
+{
+    /** Mock result set. */
+    @Mock
+    private ResultSet resultSet;
+
+    @Override
+    public void setUp() throws Exception
+    {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        when(resultSet.getInt(1)).thenReturn(0);
+        when(resultSet.getInt(2)).thenReturn(-273343444);
+        when(resultSet.getInt(3)).thenReturn(353344556);
+        when(resultSet.getInt(0)).thenThrow(
+                new SQLException("index must be >= 1"));
+        when(resultSet.wasNull()).thenReturn(true);
+    }
+
+    /**
+     * Tests the processRow method for a mapper without internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRow() throws Exception
+    {
+        // prepare
+        IntegerMapper mapper = new IntegerMapper();
+
+        // execute
+        Integer result1 = mapper.processRow(resultSet, 0);
+        Integer result2 = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(null, result1);
+        assertEquals(Integer.valueOf(-273343444), result2);
+        // verify mock (verification order not relevant)
+        verify(resultSet).getInt(1);
+        verify(resultSet).getInt(2);
+        verify(resultSet).wasNull();
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method for a mapper with internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowInternalOffset() throws Exception
+    {
+        // prepare
+        IntegerMapper mapper = new IntegerMapper(1);
+
+        // execute
+        Integer result1 = mapper.processRow(resultSet, 0);
+        Integer result2 = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(Integer.valueOf(-273343444), result1);
+        assertEquals(Integer.valueOf(353344556), result2);
+        verify(resultSet).getInt(2);
+        verify(resultSet).getInt(3);
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method if the resultSet throws a SqlException.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowSqlException() throws Exception
+    {
+        // prepare
+        IntegerMapper mapper = new IntegerMapper();
+
+        // execute
+        try
+        {
+            mapper.processRow(resultSet, -1);
+            // verify 1
+            fail("Exception expected");
+        }
+        catch (TorqueException e)
+        {
+            // verify 2
+            assertEquals(
+                    "Result could not be mapped to a Integer",
+                    e.getMessage());
+            assertEquals(SQLException.class, e.getCause().getClass());
+            assertEquals("index must be >= 1", e.getCause().getMessage());
+            verify(resultSet).getInt(0);
+            verifyNoMoreInteractions(resultSet);
+        }
+    }
+}

Added: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/LongMapperTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/LongMapperTest.java?rev=1380467&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/LongMapperTest.java
(added)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/LongMapperTest.java
Tue Sep  4 07:33:05 2012
@@ -0,0 +1,109 @@
+package org.apache.torque.om.mapper;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.apache.torque.BaseTestCase;
+import org.apache.torque.TorqueException;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class LongMapperTest extends BaseTestCase
+{
+    /** Mock result set. */
+    @Mock
+    private ResultSet resultSet;
+
+    @Override
+    public void setUp() throws Exception
+    {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        when(resultSet.getLong(1)).thenReturn(0L);
+        when(resultSet.getLong(2)).thenReturn(-2733434442345777L);
+        when(resultSet.getLong(3)).thenReturn(35334455623667566L);
+        when(resultSet.getLong(0)).thenThrow(
+                new SQLException("index must be >= 1"));
+        when(resultSet.wasNull()).thenReturn(true);
+    }
+
+    /**
+     * Tests the processRow method for a mapper without internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRow() throws Exception
+    {
+        // prepare
+        LongMapper mapper = new LongMapper();
+
+        // execute
+        Long result1 = mapper.processRow(resultSet, 0);
+        Long result2 = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(null, result1);
+        assertEquals(Long.valueOf(-2733434442345777L), result2);
+        // verify mock (verification order not relevant)
+        verify(resultSet).getLong(1);
+        verify(resultSet).getLong(2);
+        verify(resultSet).wasNull();
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method for a mapper with internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowInternalOffset() throws Exception
+    {
+        // prepare
+        LongMapper mapper = new LongMapper(1);
+
+        // execute
+        Long result1 = mapper.processRow(resultSet, 0);
+        Long result2 = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(Long.valueOf(-2733434442345777L), result1);
+        assertEquals(Long.valueOf(35334455623667566L), result2);
+        verify(resultSet).getLong(2);
+        verify(resultSet).getLong(3);
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method if the resultSet throws a SqlException.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowSqlException() throws Exception
+    {
+        // prepare
+        LongMapper mapper = new LongMapper();
+
+        // execute
+        try
+        {
+            mapper.processRow(resultSet, -1);
+            // verify 1
+            fail("Exception expected");
+        }
+        catch (TorqueException e)
+        {
+            // verify 2
+            assertEquals(
+                    "Result could not be mapped to a Long",
+                    e.getMessage());
+            assertEquals(SQLException.class, e.getCause().getClass());
+            assertEquals("index must be >= 1", e.getCause().getMessage());
+            verify(resultSet).getLong(0);
+            verifyNoMoreInteractions(resultSet);
+        }
+    }
+}

Added: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/ObjectListMapperTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/ObjectListMapperTest.java?rev=1380467&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/ObjectListMapperTest.java
(added)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/ObjectListMapperTest.java
Tue Sep  4 07:33:05 2012
@@ -0,0 +1,445 @@
+package org.apache.torque.om.mapper;
+
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Date;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.torque.BaseTestCase;
+import org.apache.torque.TorqueException;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class ObjectListMapperTest extends BaseTestCase
+{
+    /** Mock result set. */
+    @Mock
+    private ResultSet resultSet;
+
+    /** Mock result set metadata. */
+    @Mock
+    private ResultSetMetaData resultSetMetaData;
+
+    /** Mock array. */
+    @Mock
+    private Array array;
+
+    /** Mock blob. */
+    @Mock
+    private Blob blob;
+
+    /** Mock clob. */
+    @Mock
+    private Clob clob;
+
+    /** Mock input stream. */
+    @Mock
+    private InputStream inputStream;
+
+    /** Mock reader. */
+    @Mock
+    private Reader reader;
+
+    /** Mock ref. */
+    @Mock
+    private Ref ref;
+
+    /** Object instance. */
+    private Object object = new Object();
+
+    @Override
+    public void setUp() throws Exception
+    {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        when(resultSet.getObject(0)).thenThrow(
+                new SQLException("index is 1 based"));
+        when(resultSet.getBigDecimal(1)).thenReturn(null);
+        when(resultSet.getObject(1)).thenReturn(null);
+        when(resultSet.getArray(2)).thenReturn(array);
+        when(resultSet.getObject(2)).thenReturn(array);
+        when(resultSet.getBigDecimal(3)).thenReturn(new BigDecimal("123.456"));
+        when(resultSet.getObject(3)).thenReturn(new BigDecimal("123.456"));
+        when(resultSet.getBinaryStream(4)).thenReturn(inputStream);
+        when(resultSet.getObject(4)).thenReturn(inputStream);
+        when(resultSet.getBlob(5)).thenReturn(blob);
+        when(resultSet.getBoolean(6)).thenReturn(true);
+        when(resultSet.getByte(7)).thenReturn(Byte.valueOf("7"));
+        when(resultSet.getBytes(8)).thenReturn(new byte[] {8});
+        when(resultSet.getCharacterStream(9)).thenReturn(reader);
+        when(resultSet.getClob(10)).thenReturn(clob);
+        when(resultSet.getDate(11)).thenReturn(new Date(11L));
+        when(resultSet.getDouble(12)).thenReturn(12d);
+        when(resultSet.getFloat(13)).thenReturn(13f);
+        when(resultSet.getInt(14)).thenReturn(14);
+        when(resultSet.getLong(15)).thenReturn(15L);
+        when(resultSet.getObject(16)).thenReturn(object);
+        when(resultSet.getRef(17)).thenReturn(ref);
+        when(resultSet.getShort(18)).thenReturn(Short.valueOf("18"));
+        when(resultSet.getString(19)).thenReturn("abc");
+        when(resultSet.getTime(20)).thenReturn(new Time(20L));
+        when(resultSet.getTimestamp(21)).thenReturn(new Timestamp(21L));
+        when(resultSet.getURL(22)).thenReturn(new URL("http://22"));
+        when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
+        when(resultSetMetaData.getColumnCount()).thenReturn(3);
+    }
+
+    /**
+     * Tests the processRow method for a mapper where the length is determined
+     * from the Metadata.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowLengthDeterminedFromMetadata() throws Exception
+    {
+        // prepare
+        ObjectListMapper mapper = new ObjectListMapper();
+
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 0);
+
+        // verify
+        assertEquals(3, result.size());
+        assertEquals(null, result.get(0));
+        assertEquals(array, result.get(1));
+        assertEquals(new BigDecimal("123.456"), result.get(2));
+        verify(resultSet).getMetaData();
+        verify(resultSetMetaData).getColumnCount();
+        verify(resultSet).getObject(1);
+        verify(resultSet).getObject(2);
+        verify(resultSet).getObject(3);
+        verifyNoMoreInteractions(resultSet, resultSetMetaData);
+    }
+
+    /**
+     * Tests the processRow method for a mapper with offset
+     * where the length is determined from the Metadata.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowLengthDeterminedFromMetadataWithOffset()
+            throws Exception
+    {
+        // prepare
+        ObjectListMapper mapper = new ObjectListMapper();
+
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(2, result.size());
+        assertEquals(array, result.get(0));
+        assertEquals(new BigDecimal("123.456"), result.get(1));
+        verify(resultSet).getMetaData();
+        verify(resultSetMetaData).getColumnCount();
+        verify(resultSet).getObject(2);
+        verify(resultSet).getObject(3);
+        verifyNoMoreInteractions(resultSet, resultSetMetaData);
+    }
+
+    /**
+     * Tests the processRow method for a mapper with a fixed column count.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowLenghtAsArgument() throws Exception
+    {
+        // prepare
+        ObjectListMapper mapper = new ObjectListMapper(2);
+
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(2, result.size());
+        assertEquals(array, result.get(0));
+        assertEquals(new BigDecimal("123.456"), result.get(1));
+        verify(resultSet).getObject(2);
+        verify(resultSet).getObject(3);
+        verifyNoMoreInteractions(resultSet, resultSetMetaData);
+    }
+
+    /**
+     * Tests the processRow method for a mapper with a fixed column count.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowClassListAsArgument() throws Exception
+    {
+        // prepare
+        List<Class<?>> classList = new ArrayList<Class<?>>();
+        classList.add(BigDecimal.class);
+        classList.add(Array.class);
+        classList.add(BigDecimal.class);
+        classList.add(InputStream.class);
+        classList.add(Blob.class);
+        classList.add(Boolean.class);
+        classList.add(Byte.class);
+        classList.add(byte[].class);
+        classList.add(Reader.class);
+        classList.add(Clob.class);
+        classList.add(Date.class);
+        classList.add(Double.class);
+        classList.add(Float.class);
+        classList.add(Integer.class);
+        classList.add(Long.class);
+        classList.add(Object.class);
+        classList.add(Ref.class);
+        classList.add(Short.class);
+        classList.add(String.class);
+        classList.add(Time.class);
+        classList.add(Timestamp.class);
+        classList.add(URL.class);
+        ObjectListMapper mapper = new ObjectListMapper(classList);
+
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 0);
+
+        // verify
+        assertEquals(22, result.size());
+        assertEquals(null, result.get(0));
+        assertEquals(array, result.get(1));
+        assertEquals(new BigDecimal("123.456"), result.get(2));
+        assertEquals(inputStream, result.get(3));
+        assertEquals(blob, result.get(4));
+        assertEquals(true, result.get(5));
+        assertEquals(Byte.valueOf("7"), result.get(6));
+        assertTrue(Arrays.equals(new byte[] {8}, (byte[]) result.get(7)));
+        assertEquals(reader, result.get(8));
+        assertEquals(clob, result.get(9));
+        assertEquals(new Date(11L), result.get(10));
+        assertEquals(12d, result.get(11));
+        assertEquals(13f, result.get(12));
+        assertEquals(14, result.get(13));
+        assertEquals(15L, result.get(14));
+        assertEquals(object, result.get(15));
+        assertEquals(ref, result.get(16));
+        assertEquals(Short.valueOf("18"), result.get(17));
+        assertEquals("abc", result.get(18));
+        assertEquals(new Time(20L), result.get(19));
+        assertEquals(new Timestamp(21L), result.get(20));
+        assertEquals(new URL("http://22"), result.get(21));
+
+
+        verify(resultSet).getBigDecimal(1);
+        verify(resultSet).getArray(2);
+        verify(resultSet).getBigDecimal(3);
+        verify(resultSet).getBinaryStream(4);
+        verify(resultSet).getBlob(5);
+        verify(resultSet).getBoolean(6);
+        verify(resultSet).getByte(7);
+        verify(resultSet).getBytes(8);
+        verify(resultSet).getCharacterStream(9);
+        verify(resultSet).getClob(10);
+        verify(resultSet).getDate(11);
+        verify(resultSet).getDouble(12);
+        verify(resultSet).getFloat(13);
+        verify(resultSet).getInt(14);
+        verify(resultSet).getLong(15);
+        verify(resultSet).getObject(16);
+        verify(resultSet).getRef(17);
+        verify(resultSet).getShort(18);
+        verify(resultSet).getString(19);
+        verify(resultSet).getTime(20);
+        verify(resultSet).getTimestamp(21);
+        verify(resultSet).getURL(22);
+        verifyNoMoreInteractions(resultSet, resultSetMetaData);
+    }
+
+    /**
+     * Tests the processRow method if the resultSet throws a SqlException.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowSqlException() throws Exception
+    {
+        // prepare
+        ObjectListMapper mapper = new ObjectListMapper(1);
+
+        // execute
+        try
+        {
+            mapper.processRow(resultSet, -1);
+            // verify 1
+            fail("Exception expected");
+        }
+        catch (TorqueException e)
+        {
+            // verify 2
+            assertEquals("java.sql.SQLException: index is 1 based", e.getMessage());
+            assertEquals(SQLException.class, e.getCause().getClass());
+            assertEquals("index is 1 based", e.getCause().getMessage());
+            verify(resultSet).getObject(0);
+            verifyNoMoreInteractions(resultSet);
+        }
+    }
+
+    /**
+     * Tests the processRow method if the resultSet throws a SqlException.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testUnknownClass() throws Exception
+    {
+        // prepare
+        List<Class<?>> classList = new ArrayList<Class<?>>();
+        classList.add(RecordMapper.class);
+        ObjectListMapper mapper = new ObjectListMapper(classList);
+
+        // execute
+        try
+        {
+            mapper.processRow(resultSet, -1);
+            // verify 1
+            fail("Exception expected");
+        }
+        catch (IllegalArgumentException e)
+        {
+            // verify 2
+            assertEquals("Unknown convertClass "
+              + "org.apache.torque.om.mapper.RecordMapper at position 0",
+              e.getMessage());
+            verifyNoMoreInteractions(resultSet);
+        }
+    }
+
+    public void testByteNull() throws Exception
+    {
+        // prepare
+        byte zero = 0;
+        when(resultSet.getByte(1)).thenReturn(zero);
+        when(resultSet.wasNull()).thenReturn(true);
+        List<Class<?>> classList = new ArrayList<Class<?>>();
+        classList.add(Byte.class);
+        ObjectListMapper mapper = new ObjectListMapper(classList);
+
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 0);
+
+        // verify
+        assertEquals(1, result.size());
+        assertEquals(null, result.get(0));
+        verify(resultSet).getByte(1);
+        verify(resultSet).wasNull();
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    public void testShortNull() throws Exception
+    {
+        // prepare
+        short zero = 0;
+        when(resultSet.getShort(1)).thenReturn(zero);
+        when(resultSet.wasNull()).thenReturn(true);
+        List<Class<?>> classList = new ArrayList<Class<?>>();
+        classList.add(Short.class);
+        ObjectListMapper mapper = new ObjectListMapper(classList);
+
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 0);
+
+        // verify
+        assertEquals(1, result.size());
+        assertEquals(null, result.get(0));
+        verify(resultSet).getShort(1);
+        verify(resultSet).wasNull();
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    public void testIntegerNull() throws Exception
+    {
+        // prepare
+        when(resultSet.getInt(1)).thenReturn(0);
+        when(resultSet.wasNull()).thenReturn(true);
+        List<Class<?>> classList = new ArrayList<Class<?>>();
+        classList.add(Integer.class);
+        ObjectListMapper mapper = new ObjectListMapper(classList);
+
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 0);
+
+        // verify
+        assertEquals(1, result.size());
+        assertEquals(null, result.get(0));
+        verify(resultSet).getInt(1);
+        verify(resultSet).wasNull();
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    public void testLongNull() throws Exception
+    {
+        // prepare
+        when(resultSet.getLong(1)).thenReturn(0L);
+        when(resultSet.wasNull()).thenReturn(true);
+        List<Class<?>> classList = new ArrayList<Class<?>>();
+        classList.add(Long.class);
+        ObjectListMapper mapper = new ObjectListMapper(classList);
+
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 0);
+
+        // verify
+        assertEquals(1, result.size());
+        assertEquals(null, result.get(0));
+        verify(resultSet).getLong(1);
+        verify(resultSet).wasNull();
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    public void testDoubleNull() throws Exception
+    {
+        // prepare
+        when(resultSet.getDouble(1)).thenReturn(0d);
+        when(resultSet.wasNull()).thenReturn(true);
+        List<Class<?>> classList = new ArrayList<Class<?>>();
+        classList.add(Double.class);
+        ObjectListMapper mapper = new ObjectListMapper(classList);
+
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 0);
+
+        // verify
+        assertEquals(1, result.size());
+        assertEquals(null, result.get(0));
+        verify(resultSet).getDouble(1);
+        verify(resultSet).wasNull();
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    public void testFloatNull() throws Exception
+    {
+        // prepare
+        when(resultSet.getFloat(1)).thenReturn(0f);
+        when(resultSet.wasNull()).thenReturn(true);
+        List<Class<?>> classList = new ArrayList<Class<?>>();
+        classList.add(Float.class);
+        ObjectListMapper mapper = new ObjectListMapper(classList);
+
+        // execute
+        List<Object> result = mapper.processRow(resultSet, 0);
+
+        // verify
+        assertEquals(1, result.size());
+        assertEquals(null, result.get(0));
+        verify(resultSet).getFloat(1);
+        verify(resultSet).wasNull();
+        verifyNoMoreInteractions(resultSet);
+    }
+}

Added: db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/StringMapperTest.java
URL: http://svn.apache.org/viewvc/db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/StringMapperTest.java?rev=1380467&view=auto
==============================================================================
--- db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/StringMapperTest.java
(added)
+++ db/torque/torque4/trunk/torque-runtime/src/test/java/org/apache/torque/om/mapper/StringMapperTest.java
Tue Sep  4 07:33:05 2012
@@ -0,0 +1,106 @@
+package org.apache.torque.om.mapper;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.apache.torque.BaseTestCase;
+import org.apache.torque.TorqueException;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class StringMapperTest extends BaseTestCase
+{
+    /** Mock result set. */
+    @Mock
+    private ResultSet resultSet;
+
+    @Override
+    public void setUp() throws Exception
+    {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        when(resultSet.getString(1)).thenReturn(null);
+        when(resultSet.getString(2)).thenReturn("");
+        when(resultSet.getString(3)).thenReturn("abcDEF");
+        when(resultSet.getString(0)).thenThrow(
+                new SQLException("index must be >= 1"));
+    }
+
+    /**
+     * Tests the processRow method for a mapper without internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRow() throws Exception
+    {
+        // prepare
+        StringMapper mapper = new StringMapper();
+
+        // execute
+        String result1 = mapper.processRow(resultSet, 0);
+        String result2 = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals(null, result1);
+        assertEquals("", result2);
+        verify(resultSet).getString(1);
+        verify(resultSet).getString(2);
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method for a mapper with internal Offset.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowInternalOffset() throws Exception
+    {
+        // prepare
+        StringMapper mapper = new StringMapper(1);
+
+        // execute
+        String result1 = mapper.processRow(resultSet, 0);
+        String result2 = mapper.processRow(resultSet, 1);
+
+        // verify
+        assertEquals("", result1);
+        assertEquals("abcDEF", result2);
+        verify(resultSet).getString(2);
+        verify(resultSet).getString(3);
+        verifyNoMoreInteractions(resultSet);
+    }
+
+    /**
+     * Tests the processRow method if the resultSet throws a SqlException.
+     *
+     * @throws Exception if the test fails
+     */
+    public void testProcessRowSqlException() throws Exception
+    {
+        // prepare
+        StringMapper mapper = new StringMapper();
+
+        // execute
+        try
+        {
+            mapper.processRow(resultSet, -1);
+            // verify 1
+            fail("Exception expected");
+        }
+        catch (TorqueException e)
+        {
+            // verify 2
+            assertEquals(
+                    "Result could not be mapped to a String",
+                    e.getMessage());
+            assertEquals(SQLException.class, e.getCause().getClass());
+            assertEquals("index must be >= 1", e.getCause().getMessage());
+            verify(resultSet).getString(0);
+            verifyNoMoreInteractions(resultSet);
+        }
+    }
+}



---------------------------------------------------------------------
To unsubscribe, e-mail: torque-dev-unsubscribe@db.apache.org
For additional commands, e-mail: torque-dev-help@db.apache.org


Mime
View raw message