diff options
Diffstat (limited to 'israfil-foundation-testing/src')
6 files changed, 2252 insertions, 0 deletions
diff --git a/israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/MockResultSet.java b/israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/MockResultSet.java new file mode 100644 index 0000000..4de4a63 --- /dev/null +++ b/israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/MockResultSet.java @@ -0,0 +1,1350 @@ +/*
+ * Copyright (c) 2003, 2004, 2005, 2006 Israfil Consulting Services Corporation
+ * Copyright (c) 2003, 2004, 2005, 2006 Christian Edward Gruber
+ * All Rights Reserved
+ *
+ * This software is licensed under the Berkeley Standard Distribution license,
+ * (BSD license), as defined below:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of Israfil Consulting Services nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * $Id: MockResultSet.java 517M 2007-07-09 20:00:15Z (local) $
+ */
+package net.israfil.foundation.mock.sql;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+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.NClob;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.List;
+import java.util.Map;
+
+import net.israfil.foundation.mock.sql.MockResultSetMetaData.ColSpec;
+
+/**
+ * A Mock implementation of ResultSet that takes an array of column
+ * names and an array or rows, where rows are arrays of data. A Mock
+ * ResultSet can be used in unit testing where database access needs
+ * to be stubbed out.
+ *
+ * @author <a href="mailto:cgruber@israfil.net">Christian Edward Gruber </a>
+ */
+public class MockResultSet implements ResultSet {
+
+ public MockResultSetMetaData metadata;
+
+ protected List<Row> data;
+ public List<Row> getData() { return data; }
+ int cursorPosition = 0;
+ boolean insertRow = false;
+ private final static int BEFOREFIRST = 0;
+ private final int AFTERLAST;
+ protected int concurrency = CONCUR_READ_ONLY;
+ protected int fetchDirection = FETCH_UNKNOWN;
+ protected int fetchSize = 0;
+ protected Statement statement = null;
+ protected boolean wasNull = false;
+ boolean open = false;
+
+ private MockResultSet(int size) {
+ AFTERLAST = size+1;
+ }
+
+ /**
+ * The main constructor, which takes an array of strings representing
+ * the columns of the supposed DataReader, and an array of string arrays
+ * representing the row data. With this, one can simulate a call to the
+ * database.
+ *
+ * @param columns the columns to be simulated
+ * @param rows the rows to be simulated
+ *
+ */
+ public MockResultSet(String[] columns, Object[][] rows) {
+ this((rows==null)?0:rows.length);
+ metadata = new MockResultSetMetaData(columns);
+ primeRows(rows);
+ }
+
+ /**
+ * The main constructor, which takes an array of strings representing
+ * the columns of the supposed DataReader, and an array of string arrays
+ * representing the row data. With this, one can simulate a call to the
+ * database.
+ *
+ * @param columns the columns to be simulated
+ * @param rows the rows to be simulated
+ *
+ */
+ public MockResultSet(ColSpec[] columns, Object[][] rows) {
+ this((rows==null)?0:rows.length);
+ metadata = new MockResultSetMetaData(columns);
+ primeRows(rows);
+ }
+
+ /**
+ * Private method that takes given row data and populates the internal
+ * structures with said data.
+ * @param rows
+ */
+ private void primeRows(Object[][] rows) {
+ if (rows == null) rows = new String[][]{};
+ try {
+ data = new ArrayList<Row>(metadata.getColumnCount());
+ for (int rowNum = 0; rowNum < rows.length; rowNum++) {
+ data.add(new Row(metadata,new ArrayList<Object>(Arrays.asList(rows[rowNum]))));
+ }
+ } catch (SQLException e) {
+ throw new RuntimeException(e);
+ }
+ cursorPosition = 0;
+ open = true;
+ }
+
+ public void finalize() throws Throwable {
+ data = null;
+ metadata = null;
+ super.finalize();
+ }
+
+ /**
+ * Moves the cursor to the given row number in this ResultSet object.
+ *
+ * If the row number is positive, the cursor moves to the given row number
+ * with respect to the beginning of the result set. The first row is row 1,
+ * the second is row 2, and so on.
+ *
+ * If the given row number is negative, the cursor moves to an absolute row
+ * position with respect to the end of the result set. For example, calling
+ * the method absolute(-1) positions the cursor on the last row; calling the
+ * method absolute(-2) moves the cursor to the next-to-last row, and so on.
+ *
+ * An attempt to position the cursor beyond the first/last row in the result
+ * set leaves the cursor before the first row or after the last row.
+ *
+ * Note: Calling absolute(1) is the same as calling first(). Calling
+ * absolute(-1) is the same as calling last().
+ *
+ * @param row - the number of the row to which the cursor should move. A positive number indicates the row number counting from the beginning of the result set; a negative number indicates the row number counting from the end of the result set
+ * @return true if the cursor is on the result set; false otherwise
+ */
+ public boolean absolute(int row) throws SQLException {
+ // the number of the row to which the cursor should move.
+ // A positive number indicates the row number counting from
+ // the beginning of the result set; a negative number indicates
+ // the row number counting from the end of the result set.
+ if (row > 0) {
+ if (BEFOREFIRST + row < AFTERLAST) {
+ cursorPosition = BEFOREFIRST + row;
+ return true;
+ } else {
+ cursorPosition = AFTERLAST;
+ return false;
+ }
+ } else if (row < 0) {
+ if (AFTERLAST + row > BEFOREFIRST) {
+ cursorPosition = AFTERLAST + row;
+ return true;
+ } else {
+ cursorPosition = BEFOREFIRST;
+ return false;
+ }
+ } else /* offset == 0 */ {
+ // This is essentially beforeFirst();
+ cursorPosition = 0;
+ return false;
+ }
+ }
+
+ public void afterLast() throws SQLException {
+ absolute(data.size()+1);
+ }
+
+ public void beforeFirst() throws SQLException {
+ absolute(0);
+ }
+
+ public void cancelRowUpdates() throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public void clearWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public void close() throws SQLException {
+ open = false;
+ }
+
+ public void deleteRow() throws SQLException {
+ if (insertRow) throw new SQLException("Cannot delete the insert row.");
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public int findColumn(String column) throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public boolean first() throws SQLException {
+ return absolute(1);
+ }
+
+ public Object getInternalValue(int rowNumber, int column) {
+ try {
+ return processAccessedObject(data.get(rowNumber-1).get(column));
+ } catch (SQLException e) { throw new RuntimeException(e); }
+ }
+
+ public Object getInternalValue(int rowNumber, String column) {
+ try {
+ return processAccessedObject(data.get(rowNumber-1).get(column));
+ } catch (SQLException e) { throw new RuntimeException(e); }
+ }
+
+ public Object processAccessedObject(Object o) {
+ if (o == null) wasNull = true;
+ return o;
+ }
+
+ public Array getArray(int column) throws SQLException {
+ return (Array)getInternalValue(cursorPosition,column);
+ }
+
+ public Array getArray(String column) throws SQLException {
+ return (Array)getInternalValue(cursorPosition,column);
+ }
+
+ public InputStream getAsciiStream(int column) throws SQLException {
+ return (InputStream)getInternalValue(cursorPosition,column);
+ }
+
+ public InputStream getAsciiStream(String column) throws SQLException {
+ return (InputStream)getInternalValue(cursorPosition,column);
+ }
+
+ public BigDecimal getBigDecimal(int column, int scale) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ if (o == null) return null;
+ BigDecimal bd;
+ if (o instanceof String) bd = new BigDecimal((String)o);
+ else if (o instanceof Number) bd = new BigDecimal(((Number)o).doubleValue());
+ else if (o instanceof java.util.Date) bd = new BigDecimal(((java.util.Date)o).getTime());
+ else if (o instanceof Calendar) bd = new BigDecimal(((Calendar)o).getTimeInMillis());
+ else if (o instanceof char[]) bd = new BigDecimal(((char[])o));
+ else if (o instanceof Boolean) return new BigDecimal(((Boolean)o).booleanValue() ? 1 : 0);
+ else bd = new BigDecimal(String.valueOf(o));
+ bd.setScale(scale);
+ return bd;
+ }
+
+ public BigDecimal getBigDecimal(int column) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ if (o == null) return null;
+ BigDecimal bd;
+ if (o instanceof String) bd = new BigDecimal((String)o);
+ else if (o instanceof Number) bd = new BigDecimal(((Number)o).doubleValue());
+ else if (o instanceof java.util.Date) bd = new BigDecimal(((java.util.Date)o).getTime());
+ else if (o instanceof Calendar) bd = new BigDecimal(((Calendar)o).getTimeInMillis());
+ else if (o instanceof char[]) bd = new BigDecimal(((char[])o));
+ else if (o instanceof Boolean) return new BigDecimal(((Boolean)o).booleanValue() ? 1 : 0);
+ else bd = new BigDecimal(String.valueOf(o));
+ return bd;
+ }
+
+ public BigDecimal getBigDecimal(String column, int scale) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ if (o == null) return null;
+ BigDecimal bd;
+ if (o instanceof String) bd = new BigDecimal((String)o);
+ else if (o instanceof Number) bd = new BigDecimal(((Number)o).doubleValue());
+ else if (o instanceof java.util.Date) bd = new BigDecimal(((java.util.Date)o).getTime());
+ else if (o instanceof Calendar) bd = new BigDecimal(((Calendar)o).getTimeInMillis());
+ else if (o instanceof char[]) bd = new BigDecimal(((char[])o));
+ else if (o instanceof Boolean) return new BigDecimal(((Boolean)o).booleanValue() ? 1 : 0);
+ else bd = new BigDecimal(String.valueOf(o));
+ bd.setScale(scale);
+ return bd;
+ }
+
+ public BigDecimal getBigDecimal(String column) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ if (o == null) return null;
+ BigDecimal bd;
+ if (o instanceof String) bd = new BigDecimal((String)o);
+ else if (o instanceof Number) bd = new BigDecimal(((Number)o).doubleValue());
+ else if (o instanceof java.util.Date) bd = new BigDecimal(((java.util.Date)o).getTime());
+ else if (o instanceof Calendar) bd = new BigDecimal(((Calendar)o).getTimeInMillis());
+ else if (o instanceof char[]) bd = new BigDecimal(((char[])o));
+ else if (o instanceof Boolean) return new BigDecimal(((Boolean)o).booleanValue() ? 1 : 0);
+ else bd = new BigDecimal(String.valueOf(o));
+ return bd;
+ }
+
+ public InputStream getBinaryStream(int column) throws SQLException {
+ return (InputStream)getInternalValue(cursorPosition,column);
+ }
+
+ public InputStream getBinaryStream(String column) throws SQLException {
+ return (InputStream)getInternalValue(cursorPosition,column);
+ }
+
+ public Blob getBlob(int column) throws SQLException {
+ return new MockBlob(getBytes(column));
+ }
+
+ public Blob getBlob(String column) throws SQLException {
+ return new MockBlob(getBytes(column));
+ }
+
+ public boolean getBoolean(int column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return false;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) return ((Number)o).byteValue() != 0;
+ else return Boolean.valueOf(String.valueOf(o));
+ }
+
+ public boolean getBoolean(String column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return false;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) return ((Number)o).byteValue() != 0;
+ else return Boolean.valueOf(String.valueOf(o));
+ }
+
+ public byte getByte(int column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).byteValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? (byte)1 : (byte)0 ;
+ } else return Byte.valueOf(String.valueOf(o));
+ }
+
+ public byte getByte(String column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).byteValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? (byte)1 : (byte)0 ;
+ } else return Byte.valueOf(String.valueOf(o));
+ }
+
+ public byte[] getBytes(int column) throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public byte[] getBytes(String column) throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public Reader getCharacterStream(int column) throws SQLException {
+ return (Reader)getInternalValue(cursorPosition,column);
+ }
+
+ public Reader getCharacterStream(String column) throws SQLException {
+ return (Reader)getInternalValue(cursorPosition,column);
+ }
+
+ public Clob getClob(int column) throws SQLException {
+ return (Clob)getInternalValue(cursorPosition,column);
+ }
+
+ public Clob getClob(String column) throws SQLException {
+ return (Clob)getInternalValue(cursorPosition,column);
+ }
+
+ public int getConcurrency() throws SQLException {
+ return concurrency;
+ }
+
+ public void setConcurrency(int concurrency) {
+ this.concurrency = concurrency;
+ }
+ public String getCursorName() throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public Date getDate(int column, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public Date getDate(int column) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ if (o == null) return null;
+ if (o instanceof Date) return (Date)o;
+ if (o instanceof java.util.Date)
+ return new Date(((java.util.Date)o).getTime());
+ if (o instanceof Calendar)
+ return new Date(((Calendar)o).getTimeInMillis());
+ return Date.valueOf(String.valueOf(o));
+ }
+
+ public Date getDate(String column, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public Date getDate(String column) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ if (o == null) return null;
+ if (o instanceof Date) return (Date)o;
+ if (o instanceof java.util.Date)
+ return new Date(((java.util.Date)o).getTime());
+ if (o instanceof Calendar)
+ return new Date(((Calendar)o).getTimeInMillis());
+ return Date.valueOf(String.valueOf(o));
+ }
+
+ public double getDouble(int column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).doubleValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? 1 : 0 ;
+ } else return Double.valueOf(String.valueOf(o));
+ }
+
+ public double getDouble(String column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).doubleValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? 1 : 0 ;
+ } else return Double.valueOf(String.valueOf(o));
+ }
+
+ public int getFetchDirection() throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public int getFetchSize() throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public float getFloat(int column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).floatValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? 1 :0 ;
+ } else return Float.valueOf(String.valueOf(o));
+ }
+
+ public float getFloat(String column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).floatValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? 1 :0 ;
+ } else return Float.valueOf(String.valueOf(o));
+ }
+
+ public int getInt(int column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).intValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? 1 :0 ;
+ } else return Integer.valueOf(String.valueOf(o));
+ }
+
+ public int getInt(String column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).intValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? 1 :0 ;
+ } else return Integer.valueOf(String.valueOf(o));
+ }
+
+ public long getLong(int column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).longValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? 1 :0 ;
+ } else return Long.valueOf(String.valueOf(o));
+ }
+
+ public long getLong(String column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).longValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? 1 :0 ;
+ } else return Long.valueOf(String.valueOf(o));
+ }
+
+ public ResultSetMetaData getMetaData() throws SQLException {
+ return metadata;
+ }
+
+ public Object getObject(int column, Map<String, Class<?>> mapping) throws SQLException {
+ throw new UnsupportedOperationException("Unimplented feature.");
+ }
+
+ public Object getObject(int column) throws SQLException {
+ return (Object)getInternalValue(cursorPosition,column);
+ }
+
+ public Object getObject(String column, Map<String, Class<?>> mapping) throws SQLException {
+ throw new UnsupportedOperationException("Unimplented feature.");
+ }
+
+ public Object getObject(String column) throws SQLException {
+ return (Object)getInternalValue(cursorPosition,column);
+ }
+
+ public Ref getRef(int column) throws SQLException {
+ throw new UnsupportedOperationException("Unimplented feature.");
+ }
+
+ public Ref getRef(String column) throws SQLException {
+ throw new UnsupportedOperationException("Unimplented feature.");
+ }
+
+ public int getRow() throws SQLException {
+ return (cursorPosition > BEFOREFIRST && cursorPosition < AFTERLAST) ? cursorPosition : 0;
+ }
+
+ public short getShort(int column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).shortValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? (short)1 : (short)0 ;
+ } else return Short.valueOf(String.valueOf(o));
+ }
+
+ public short getShort(String column) throws SQLException {
+ if (getInternalValue(cursorPosition,column) == null) return 0;
+ Object o = getInternalValue(cursorPosition,column);
+ if (o instanceof Number) {
+ return ((Number)o).shortValue();
+ } else if (o instanceof Boolean) {
+ return ((Boolean)o).booleanValue() ? (short)1 : (short)0 ;
+ } else return Short.valueOf(String.valueOf(o));
+ }
+
+ public Statement getStatement() throws SQLException {
+ return null;
+ }
+
+ public String getString(int column) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ return (o == null) ? null : String.valueOf(o);
+ }
+
+ public String getString(String column) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ return (o == null) ? null : String.valueOf(o);
+ }
+
+ public Time getTime(int column, Calendar cal) throws SQLException {
+ return (Time)getInternalValue(cursorPosition,column);
+ }
+
+ public Time getTime(int column) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ if (o == null) return null;
+ if (o instanceof Time) return (Time)o;
+ if (o instanceof java.util.Date)
+ return new Time(((java.util.Date)o).getTime());
+ if (o instanceof Calendar)
+ return new Time(((Calendar)o).getTimeInMillis());
+ return Time.valueOf(String.valueOf(o));
+ }
+
+ public Time getTime(String column, Calendar cal) throws SQLException {
+ return (Time)getInternalValue(cursorPosition,column);
+ }
+
+ public Time getTime(String column) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ if (o == null) return null;
+ if (o instanceof Time) return (Time)o;
+ if (o instanceof java.util.Date)
+ return new Time(((java.util.Date)o).getTime());
+ if (o instanceof Calendar)
+ return new Time(((Calendar)o).getTimeInMillis());
+ return Time.valueOf(String.valueOf(o));
+ }
+
+ public Timestamp getTimestamp(int column, Calendar cal) throws SQLException {
+ return (Timestamp)getInternalValue(cursorPosition,column);
+ }
+
+ public Timestamp getTimestamp(int column) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ if (o == null) return null;
+ if (o instanceof Timestamp) return (Timestamp)o;
+ if (o instanceof java.util.Date)
+ return new Timestamp(((java.util.Date)o).getTime());
+ if (o instanceof Calendar)
+ return new Timestamp(((Calendar)o).getTimeInMillis());
+ return Timestamp.valueOf(String.valueOf(o));
+ }
+
+ public Timestamp getTimestamp(String column, Calendar cal) throws SQLException {
+ return (Timestamp)getInternalValue(cursorPosition,column);
+ }
+
+ public Timestamp getTimestamp(String column) throws SQLException {
+ Object o = getInternalValue(cursorPosition,column);
+ if (o == null) return null;
+ if (o instanceof Timestamp) return (Timestamp)o;
+ if (o instanceof java.util.Date)
+ return new Timestamp(((java.util.Date)o).getTime());
+ if (o instanceof Calendar)
+ return new Timestamp(((Calendar)o).getTimeInMillis());
+ return Timestamp.valueOf(String.valueOf(o));
+ }
+
+ public int getType() throws SQLException {
+ return TYPE_SCROLL_INSENSITIVE;
+ }
+
+ public InputStream getUnicodeStream(int column) throws SQLException {
+ return (InputStream)getInternalValue(cursorPosition,column);
+ }
+
+ public InputStream getUnicodeStream(String column) throws SQLException {
+ return (InputStream)getInternalValue(cursorPosition,column);
+ }
+
+ public URL getURL(int column) throws SQLException {
+ return (URL)getInternalValue(cursorPosition,column);
+ }
+
+ public URL getURL(String column) throws SQLException {
+ return (URL)getInternalValue(cursorPosition,column);
+ }
+
+ public SQLWarning getWarnings() throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ public void insertRow() throws SQLException {
+ if (!insertRow) throw new SQLException("Cannot insert any row except the insert row.");
+ // TODO: Add logic to check nullability.
+
+ }
+
+ public boolean isAfterLast() throws SQLException {
+ return cursorPosition >= AFTERLAST;
+ }
+
+ public boolean isBeforeFirst() throws SQLException {
+ return cursorPosition <= BEFOREFIRST;
+ }
+
+ public boolean isFirst() throws SQLException {
+ return data.size() > 0 && !insertRow && cursorPosition == BEFOREFIRST + 1;
+ }
+
+ public boolean isLast() throws SQLException {
+ return data.size() > 0 && !insertRow && cursorPosition == AFTERLAST - 1;
+ }
+
+ public boolean last() throws SQLException {
+ return absolute(-1);
+ }
+
+ public void moveToCurrentRow() throws SQLException {
+ insertRow = false;
+ }
+
+ public void moveToInsertRow() throws SQLException {
+ insertRow = true;
+ }
+
+ public boolean next() throws SQLException {
+ return relative(1);
+ }
+
+ public boolean previous() throws SQLException {
+ return relative(-1);
+ }
+
+ public void refreshRow() throws SQLException {
+ // TODO: blow away update row
+
+ }
+
+ public boolean relative(int offset) throws SQLException {
+ return absolute(cursorPosition+offset);
+ }
+
+ public boolean rowDeleted() throws SQLException {
+ // TODO: Possibly implement deletion detection
+ return false;
+ }
+
+ public boolean rowInserted() throws SQLException {
+ // TODO: Possibly implement insertion detection
+ return false;
+ }
+
+ public boolean rowUpdated() throws SQLException {
+ // TODO: Possibly implement update detection.
+ return false;
+ }
+
+ public void setFetchDirection(int direction) throws SQLException {
+ this.fetchDirection = direction;
+ }
+
+ public void setFetchSize(int rows) throws SQLException {
+ if (rows < 0 || (this.statement != null && rows > statement.getMaxRows()))
+ throw new SQLException("Fetch size less than zero or greater than statement's maximum rows.");
+ else this.fetchSize = rows;
+ }
+
+ public void updateArray(int column, Array x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateArray(String column, Array x) throws SQLException {
+ updateArray(findColumn(column),x);
+ }
+
+ public void updateAsciiStream(int column, InputStream x, int length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateAsciiStream(String column, InputStream x, int length) throws SQLException {
+ updateAsciiStream(findColumn(column),x,length);
+ }
+
+ public void updateBigDecimal(int column, BigDecimal x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateBigDecimal(String column, BigDecimal x) throws SQLException {
+ updateBigDecimal(findColumn(column),x);
+ }
+
+ public void updateBinaryStream(int column, InputStream x, int length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateBinaryStream(String column, InputStream x, int length) throws SQLException {
+ updateBinaryStream(findColumn(column),x,length);
+ }
+
+ public void updateBlob(int column, Blob x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateBlob(String column, Blob x) throws SQLException {
+ updateBlob(findColumn(column),x);
+ }
+
+ public void updateBoolean(int column, boolean x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateBoolean(String column, boolean x) throws SQLException {
+ updateBoolean(findColumn(column),x);
+ }
+
+ public void updateByte(int column, byte x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateByte(String column, byte x) throws SQLException {
+ updateByte(findColumn(column),x);
+ }
+
+ public void updateBytes(int column, byte[] x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateBytes(String column, byte[] x) throws SQLException {
+ updateBytes(findColumn(column),x);
+ }
+
+ public void updateCharacterStream(int column, Reader x, int length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateCharacterStream(String column, Reader reader, int length) throws SQLException {
+ updateCharacterStream(findColumn(column),reader,length);
+ }
+
+ public void updateClob(int column, Clob x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateClob(String column, Clob x) throws SQLException {
+ updateClob(findColumn(column),x);
+ }
+
+ public void updateDate(int column, Date x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateDate(String column, Date x) throws SQLException {
+ updateDate(findColumn(column),x);
+ }
+
+ public void updateDouble(int column, double x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateDouble(String column, double x) throws SQLException {
+ updateDouble(findColumn(column),x);
+ }
+
+ public void updateFloat(int column, float x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateFloat(String column, float x) throws SQLException {
+ updateFloat(findColumn(column),x);
+ }
+
+ public void updateInt(int column, int x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateInt(String column, int x) throws SQLException {
+ updateInt(findColumn(column),x);
+ }
+
+ public void updateLong(int column, long x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateLong(String column, long x) throws SQLException {
+ updateLong(findColumn(column),x);
+ }
+
+ public void updateNull(int column) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateNull(String column) throws SQLException {
+ updateNull(findColumn(column));
+ }
+
+ public void updateObject(int column, Object x, int scale) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateObject(int column, Object x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateObject(String column, Object x, int scale) throws SQLException {
+ updateObject(findColumn(column),x,scale);
+ }
+
+ public void updateObject(String column, Object x) throws SQLException {
+ updateObject(findColumn(column),x);
+ }
+
+ public void updateRef(int column, Ref x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateRef(String column, Ref x) throws SQLException {
+ updateRef(findColumn(column),x);
+ }
+
+ public void updateRow() throws SQLException {
+ // TODO: Implement update call.
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ public void updateShort(int column, short x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateShort(String column, short x) throws SQLException {
+ updateShort(findColumn(column),x);
+ }
+
+ public void updateString(int column, String x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateString(String column, String x) throws SQLException {
+ updateString(findColumn(column),x);
+ }
+
+ public void updateTime(int column, Time x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateTime(String column, Time x) throws SQLException {
+ updateTime(findColumn(column),x);
+ }
+
+ public void updateTimestamp(int column, Timestamp x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ public void updateTimestamp(String column, Timestamp x) throws SQLException {
+ updateTimestamp(findColumn(column),x);
+ }
+
+ public boolean wasNull() throws SQLException {
+ // TODO: Implement very awkward wasNull() method.
+ return false;
+ }
+
+
+ class MockBlob implements Blob {
+
+ private byte[] bytes;
+
+ public MockBlob(byte[] bytes) {
+ this.bytes=bytes;
+ }
+
+ public InputStream getBinaryStream() throws SQLException {
+ // TODO Implement getBinaryStream()
+ return null;
+ }
+
+ public byte[] getBytes(long pos, int length) throws SQLException {
+ // TODO Implement getBinaryStream()
+ if (false) bytes.hashCode();
+ return null;
+ }
+
+ public long length() throws SQLException {
+ // TODO Implement length()
+ return 0;
+ }
+
+ public long position(Blob pattern, long start) throws SQLException {
+ // TODO Implement position(Blob,long)
+ return 0;
+ }
+
+ public long position(byte[] pattern, long start) throws SQLException {
+ // TODO Implement position(byte[],long)
+ return 0;
+ }
+
+ public OutputStream setBinaryStream(long pos) throws SQLException {
+ // TODO Implement setBinaryStream(long)
+ return null;
+ }
+
+ public int setBytes(long pos, byte[] bytes, int offset, int len) throws SQLException {
+ // TODO Implement setBytes(long,byte[],int,int)
+ return 0;
+ }
+
+ public int setBytes(long pos, byte[] bytes) throws SQLException {
+ // TODO Implement setBytes(long,byte[])
+ return 0;
+ }
+
+ public void truncate(long len) throws SQLException {
+ // TODO Implement truncate(long)
+ }
+
+ @Override
+ public void free() throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public InputStream getBinaryStream(long pos, long length) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+ }
+
+
+ @Override
+ public <T> T unwrap(Class<T> iface) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public RowId getRowId(int columnIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public RowId getRowId(String columnLabel) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public void updateRowId(int columnIndex, RowId x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateRowId(String columnLabel, RowId x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public int getHoldability() throws SQLException {
+ // TODO Auto-generated method stub
+ return 0;
+ }
+
+ @Override
+ public boolean isClosed() throws SQLException {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public void updateNString(int columnIndex, String nString) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateNString(String columnLabel, String nString) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public NClob getNClob(int columnIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public NClob getNClob(String columnLabel) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public SQLXML getSQLXML(int columnIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public SQLXML getSQLXML(String columnLabel) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public String getNString(int columnIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public String getNString(String columnLabel) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Reader getNCharacterStream(int columnIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Reader getNCharacterStream(String columnLabel) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ };
+
+}
diff --git a/israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/MockResultSetMetaData.java b/israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/MockResultSetMetaData.java new file mode 100644 index 0000000..2a6b67c --- /dev/null +++ b/israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/MockResultSetMetaData.java @@ -0,0 +1,342 @@ +/*
+ * Copyright (c) 2003, 2004, 2005, 2006 Israfil Consulting Services Corporation
+ * Copyright (c) 2003, 2004, 2005, 2006 Christian Edward Gruber
+ * All Rights Reserved
+ *
+ * This software is licensed under the Berkeley Standard Distribution license,
+ * (BSD license), as defined below:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of Israfil Consulting Services nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * $Id: MockResultSetMetaData.java 13 2006-01-27 23:45:36Z cgruber $
+ */
+package net.israfil.foundation.mock.sql;
+
+import java.math.BigDecimal;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * An implementation of DatabaseMetaData that partners with ResultSet to
+ * provide database-disconnected fixed results for testing via the JDBC
+ * APIs.
+ *
+ * @author <a href="mailto:cgruber@israfil.net">Christian Edward Gruber </a>
+ */
+public class MockResultSetMetaData implements ResultSetMetaData {
+
+ public static int ZERO_ORDER_LIST_OFFSET = 1;
+ List<ColSpec> columns;
+
+ MockResultSetMetaData(String ... columns) {
+ if (columns == null) throw new IllegalArgumentException("Cannot construct a MockResultSet with no columns.");
+ ColSpec[] colspecs = new ColSpec[columns.length];
+ for (int i = 0 ; i < columns.length ; i++) {
+ colspecs[i] = new ColSpec(columns[i]);
+ }
+ prepColumns(colspecs);
+ }
+
+ MockResultSetMetaData(ColSpec ... columns) {
+ prepColumns(columns);
+ }
+
+ private void prepColumns(ColSpec ... columns) {
+ if (columns == null || columns.length <= 0)
+ throw new IllegalArgumentException("Cannot construct a MockResultSet with no columns.");
+ this.columns = new ArrayList<ColSpec>(Arrays.asList(columns));
+ }
+
+ public void finalize() throws Throwable {
+ columns = null;
+ }
+
+ /**
+ * Given a column name, this method returns the number of the column, or 0 if
+ * no such column exists.
+ *
+ * @param name
+ * @return
+ */
+ public int getColumnNumber(String name) {
+ for (int i = 1; i <= columns.size(); i++)
+ if (columns.get(i-ZERO_ORDER_LIST_OFFSET).name.equalsIgnoreCase(name)) return i;
+ return 0;
+ }
+
+ public String getCatalogName(int column) throws SQLException {
+ return "";
+ }
+
+ public String getColumnClassName(int column) throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public int getColumnCount() throws SQLException {
+ return columns.size();
+ }
+
+ public int getColumnDisplaySize(int column) throws SQLException {
+ return columns.get(column-ZERO_ORDER_LIST_OFFSET).width;
+ }
+
+ public String getColumnLabel(int column) throws SQLException {
+ if (column < 1) throw new IllegalArgumentException("Column number must be greater than 0.");
+ return columns.get(column-ZERO_ORDER_LIST_OFFSET).name;
+ }
+
+ public String getColumnName(int column) throws SQLException {
+ if (column < 1) throw new IllegalArgumentException("Column number must be greater than 0.");
+ return columns.get(column-ZERO_ORDER_LIST_OFFSET).name;
+ }
+
+ public int getColumnType(int column) throws SQLException {
+ return columns.get(column-ZERO_ORDER_LIST_OFFSET).type.sqltype;
+ }
+
+ public String getColumnTypeName(int column) throws SQLException {
+ return columns.get(column).type.name();
+ }
+
+ public int getPrecision(int column) throws SQLException {
+ return columns.get(column-ZERO_ORDER_LIST_OFFSET).precision;
+ }
+
+ public int getScale(int column) throws SQLException {
+ return columns.get(column-ZERO_ORDER_LIST_OFFSET).scale;
+ }
+
+ public String getSchemaName(int column) throws SQLException {
+ return "";
+ }
+
+ public String getTableName(int column) throws SQLException {
+ return "";
+ }
+
+ public boolean isAutoIncrement(int column) throws SQLException {
+ return false;
+ }
+
+ public boolean isCaseSensitive(int column) throws SQLException {
+ return false;
+ }
+
+ public boolean isCurrency(int column) throws SQLException {
+ return false;
+ }
+
+ public boolean isDefinitelyWritable(int column) throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public int isNullable(int column) throws SQLException {
+ return columns.get(column-ZERO_ORDER_LIST_OFFSET).nullable ? ResultSetMetaData.columnNullable : ResultSetMetaData.columnNoNulls;
+ }
+
+ public boolean isReadOnly(int column) throws SQLException {
+ return true;
+ }
+
+ public boolean isSearchable(int column) throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public boolean isSigned(int column) throws SQLException {
+ return false;
+ }
+
+ public boolean isWritable(int column) throws SQLException {
+ throw new UnsupportedOperationException("Not yet implemented.");
+ }
+
+ public static class ColSpec {
+ public final String name;
+ public final DBType type;
+ public final int width;
+ public final int precision;
+ public final int scale;
+ public final boolean nullable;
+
+ public ColSpec(String name) {
+ this.name = name;
+ this.type = DBType.OBJECT;
+ this.width = 0;
+ this.precision = 0;
+ this.scale = 0;
+ this.nullable = true;
+ }
+ public ColSpec(String name, boolean nullable) {
+ this.name = name;
+ this.type = DBType.OBJECT;
+ this.width = 0;
+ this.precision = 0;
+ this.scale = 0;
+ this.nullable = nullable;
+ }
+ public ColSpec(String name, DBType type) {
+ this.name = name;
+ this.type = type;
+ this.width = 0;
+ this.precision = 0;
+ this.scale = 0;
+ this.nullable = true;
+ }
+ public ColSpec(String name, DBType type, boolean nullable) {
+ this.name = name;
+ this.type = type;
+ this.width = 0;
+ this.precision = 0;
+ this.scale = 0;
+ this.nullable = nullable;
+ }
+ public ColSpec(String name, DBType type, int width) {
+ this.name = name;
+ this.type = type;
+ this.width = width;
+ this.precision = 0;
+ this.scale = 0;
+ this.nullable = true;
+ }
+ public ColSpec(String name, DBType type, int precision, int scale) {
+ this.name = name;
+ this.type = type;
+ this.precision = precision;
+ this.scale = scale;
+ this.width = 0;
+ this.nullable = true;
+ }
+ public ColSpec(String name, DBType type, int width, boolean nullable) {
+ this.name = name;
+ this.type = type;
+ this.width = width;
+ this.precision = 0;
+ this.scale = 0;
+ this.nullable = nullable;
+ }
+ public ColSpec(String name, DBType type, int precision, int scale, boolean nullable) {
+ this.name = name;
+ this.type = type;
+ this.precision = precision;
+ this.scale = scale;
+ this.width = 0;
+ this.nullable = nullable;
+ }
+ }
+
+ public enum DBTypeGroup {
+ Time(0), Number(1), String(2), Complex(3), Other(4);
+ public int value;
+ private DBTypeGroup(int i) {
+ value = i;
+ }
+ }
+
+ public enum DBType {
+ BLOB(byte[].class,Types.BLOB,DBTypeGroup.Other),
+ BIT(boolean.class,Types.BIT,DBTypeGroup.Number),
+ CHAR(char.class,Types.CHAR,DBTypeGroup.Number),
+ DECIMAL(BigDecimal.class,Types.DECIMAL,DBTypeGroup.Number),
+ FLOAT(float.class,Types.FLOAT,DBTypeGroup.Number),
+ DOUBLE(double.class,Types.DOUBLE,DBTypeGroup.Number),
+ SHORT(short.class,Types.SMALLINT,DBTypeGroup.Number),
+ INTEGER(int.class,Types.INTEGER,DBTypeGroup.Number),
+ LONG(long.class,Types.BIGINT,DBTypeGroup.Number),
+ BYTE(byte.class,Types.TINYINT,DBTypeGroup.Number),
+ STRING(String.class,Types.VARCHAR,DBTypeGroup.String),
+ TIMESTAMP(Timestamp.class,Types.TIMESTAMP,DBTypeGroup.Time),
+ OBJECT(Object.class,Types.JAVA_OBJECT,DBTypeGroup.Complex);
+
+ public final Class<?> javaClass;
+ public final int sqltype;
+ public final DBTypeGroup group;
+ private DBType(Class<?> javaClass, int sqltype, DBTypeGroup group) {
+ this.javaClass = javaClass;
+ this.sqltype = sqltype;
+ this.group = group;
+ }
+ public static DBType valueOf(int sqlType) {
+ switch (sqlType) {
+ case Types.BLOB:
+ case Types.CLOB:
+ case Types.BINARY:
+ case Types.VARBINARY:
+ case Types.LONGVARBINARY: return DBType.BLOB;
+
+ case Types.BIGINT: return DBType.LONG;
+
+ case Types.BOOLEAN:
+ case Types.BIT: return DBType.BIT;
+
+ case Types.CHAR: return DBType.CHAR;
+ case Types.DOUBLE: return DBType.DOUBLE;
+ case Types.FLOAT: return DBType.FLOAT;
+ case Types.INTEGER: return DBType.INTEGER;
+ case Types.SMALLINT: return DBType.SHORT;
+ case Types.TINYINT: return DBType.BYTE;
+
+ case Types.NUMERIC:
+ case Types.REAL:
+ case Types.DECIMAL: return DBType.DECIMAL;
+
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR: return DBType.STRING;
+
+ case Types.DATE:
+ case Types.TIME:
+ case Types.TIMESTAMP: return DBType.TIMESTAMP;
+
+ case Types.JAVA_OBJECT:
+ case Types.ARRAY:
+ case Types.STRUCT: return DBType.OBJECT;
+
+ case Types.REF:
+ case Types.DISTINCT:
+ case Types.NULL:
+ case Types.OTHER:
+ case Types.DATALINK:
+ default:
+ throw new IllegalArgumentException("Unsupported JDBC type");
+ }
+
+ }
+ }
+
+ @Override
+ public <T> T unwrap(Class<T> iface) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
+ // TODO Auto-generated method stub
+ return false;
+ }
+}
diff --git a/israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/Row.java b/israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/Row.java new file mode 100644 index 0000000..e48e342 --- /dev/null +++ b/israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/Row.java @@ -0,0 +1,98 @@ +/*
+ * Copyright (c) 2003, 2004, 2005, 2006 Israfil Consulting Services Corporation
+ * Copyright (c) 2003, 2004, 2005, 2006 Christian Edward Gruber
+ * All Rights Reserved
+ *
+ * This software is licensed under the Berkeley Standard Distribution license,
+ * (BSD license), as defined below:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of Israfil Consulting Services nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * $Id: Row.java 27 2006-02-13 19:40:43Z cgruber $
+ */
+package net.israfil.foundation.mock.sql;
+
+import java.sql.SQLException;
+import java.util.List;
+
+/**
+ * An object representing row data in a MockResultSet.
+ *
+ * @author <a href="mailto:cgruber@israfil.net">Christian Edward Gruber </a>
+ */
+public class Row {
+
+ MockResultSetMetaData metadata = null;
+ List<Object> data;
+
+ int cursorPosition;
+ final boolean insertRow;
+ public boolean dirty = true;
+
+ public Row(MockResultSetMetaData metadata, List<Object> rowData) {
+ this(metadata,rowData,false);
+ }
+
+ public Row(MockResultSetMetaData metadata, List<Object> rowData, boolean isInsertRow) {
+ this.metadata = metadata;
+ this.data = rowData;
+ this.insertRow = isInsertRow;
+ this.dirty = false;
+ }
+
+ public void finalize() throws Throwable {
+ data = null;
+ metadata = null;
+ super.finalize();
+ }
+
+ public void validateColumn(int i) throws SQLException {
+ if (i <= 0 || i > metadata.columns.size()) throw new SQLException("No such column #" + i);
+ }
+
+ public List<Object> getData() { return data; }
+
+ public Object get(int i) throws SQLException {
+ validateColumn(i);
+ return data.get(i-1);
+ }
+
+ public Object get(String columnName) throws SQLException {
+ return get(metadata.getColumnNumber(columnName));
+ }
+
+ public void set(int i,Object o) throws SQLException {
+ validateColumn(i);
+ data.set(i-1,o);
+ dirty = true;
+ }
+
+ public void set(String columnName,Object o) throws SQLException {
+ set(metadata.getColumnNumber(columnName),o);
+ }
+
+ public boolean isDirty() {
+ return dirty;
+ }
+}
diff --git a/israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/MockResultSetMetaDataTest.java b/israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/MockResultSetMetaDataTest.java new file mode 100644 index 0000000..8a2d7c8 --- /dev/null +++ b/israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/MockResultSetMetaDataTest.java @@ -0,0 +1,113 @@ +/*
+ * Copyright © 2003-2009 Israfil Consulting Services Corporation
+ * Copyright © 2003-2009 Christian Edward Gruber
+ * All Rights Reserved
+ *
+ * This software is licensed under the Berkeley Standard Distribution license,
+ * (BSD license), as defined below:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of Israfil Consulting Services nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * $Id: MockResultSetMetaDataTest.java 130 2006-12-31 23:22:17Z cgruber $
+ */
+package net.israfil.foundation.mock.sql;
+
+import java.sql.SQLException;
+
+import net.israfil.foundation.mock.sql.MockResultSetMetaData.ColSpec;
+import net.israfil.foundation.mock.sql.MockResultSetMetaData.DBType;
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+/**
+ *
+ * @author <a href="mailto:cgruber@israfil.net">Christian Edward Gruber </a>
+ * @author Latest: $Author: cgruber $
+ * @version $Revision: 130 $
+ */
+public class MockResultSetMetaDataTest {
+
+
+ public MockResultSetMetaDataTest() {
+ super();
+ }
+
+ @Test
+ public void testResultSetMetaDataCreation() throws SQLException {
+ String colA = "colA", colB = "colB", colC = "colC";
+ String[] cols = { colA, colB, colC };
+ MockResultSetMetaData rsmd = new MockResultSetMetaData(cols);
+ Assert.assertEquals(3,rsmd.getColumnCount());
+ Assert.assertEquals(colA,rsmd.getColumnName(1));
+ Assert.assertEquals(colB,rsmd.getColumnName(2));
+ Assert.assertEquals(colC,rsmd.getColumnName(3));
+ }
+
+ @Test
+ public void testResultSetMetaDataColumnReferencing() throws SQLException {
+ String colA = "colA", colB = "colB", colC = "colC";
+ String[] cols = { colA, colB, colC };
+ MockResultSetMetaData rsmd = new MockResultSetMetaData(cols);
+
+ Assert.assertEquals(3,rsmd.getColumnCount());
+
+ Assert.assertEquals(colA,rsmd.getColumnName(1));
+ Assert.assertEquals(colB,rsmd.getColumnName(2));
+ Assert.assertEquals(colC,rsmd.getColumnName(3));
+
+ Assert.assertEquals(1,rsmd.getColumnNumber(colA));
+ Assert.assertEquals(2,rsmd.getColumnNumber(colB));
+ Assert.assertEquals(3,rsmd.getColumnNumber(colC));
+ }
+
+ @Test
+ public void testResultSetMetaDataCreationWithColDefs() throws SQLException {
+ ColSpec colA = new ColSpec("colA", DBType.STRING, 12 );
+ ColSpec colB = new ColSpec("colB", DBType.INTEGER, 5, 0 );
+ ColSpec colC = new ColSpec("colC", DBType.DECIMAL, 3, 5, false);
+ ColSpec colD = new ColSpec("colD", DBType.STRING, 4, false);
+ ColSpec[] cols = { colA, colB, colC, colD };
+ MockResultSetMetaData rsmd = new MockResultSetMetaData(cols);
+ Assert.assertEquals(4,rsmd.getColumnCount());
+
+ Assert.assertEquals(colA.name,rsmd.getColumnName(1));
+ Assert.assertEquals(colB.name,rsmd.getColumnName(2));
+ Assert.assertEquals(colC.name,rsmd.getColumnName(3));
+ Assert.assertEquals(colD.name,rsmd.getColumnName(4));
+
+ Assert.assertEquals(colA.type.sqltype,rsmd.getColumnType(1));
+ Assert.assertEquals(colB.type.sqltype,rsmd.getColumnType(2));
+ Assert.assertEquals(colC.type.sqltype,rsmd.getColumnType(3));
+ Assert.assertEquals(colD.type.sqltype,rsmd.getColumnType(4));
+
+ Assert.assertEquals(colA.width,rsmd.getColumnDisplaySize(1));
+ Assert.assertEquals(colB.precision,rsmd.getPrecision(2));
+ Assert.assertEquals(colB.scale,rsmd.getScale(2));
+ Assert.assertEquals(colC.precision,rsmd.getPrecision(3));
+ Assert.assertEquals(colC.scale,rsmd.getScale(3));
+ Assert.assertEquals(colD.width,rsmd.getColumnDisplaySize(4));
+ }
+
+}
diff --git a/israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/MockResultSetTest.java b/israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/MockResultSetTest.java new file mode 100644 index 0000000..7dfcbcb --- /dev/null +++ b/israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/MockResultSetTest.java @@ -0,0 +1,263 @@ +/*
+ * Copyright © 2003-2009 Israfil Consulting Services Corporation
+ * Copyright © 2003-2009 Christian Edward Gruber
+ * All Rights Reserved
+ *
+ * This software is licensed under the Berkeley Standard Distribution license,
+ * (BSD license), as defined below:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of Israfil Consulting Services nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * $Id: MockResultSetTest.java 130 2006-12-31 23:22:17Z cgruber $
+ */
+package net.israfil.foundation.mock.sql;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Date;
+import java.sql.Ref;
+import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import net.israfil.foundation.mock.sql.MockResultSetMetaData.ColSpec;
+import net.israfil.foundation.mock.sql.MockResultSetMetaData.DBType;
+
+import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+/**
+ *
+ * @author <a href="mailto:cgruber@israfil.net">Christian Edward Gruber </a>
+ * @author Latest: $Author: cgruber $
+ * @version $Revision: 130 $
+ */
+public class MockResultSetTest {
+
+ ColSpec colA, colB, colC, colD, colE,
+ colF, colG, colH, colI, colJ,
+ colK;
+ ColSpec[] cols;
+ Object[][] data;
+ MockResultSet mrs;
+
+ public MockResultSetTest() {
+ super();
+ }
+
+ @SuppressWarnings("deprecation")
+ @BeforeMethod(alwaysRun=true)
+ public void setUp() throws Exception {
+ colA = new ColSpec("colA", DBType.STRING, 12 );
+ colB = new ColSpec("colB", DBType.INTEGER);
+ colC = new ColSpec("colC", DBType.SHORT);
+ colD = new ColSpec("colD", DBType.LONG);
+ colE = new ColSpec("colE", DBType.BIT);
+ colF = new ColSpec("colF", DBType.BYTE);
+ colG = new ColSpec("colG", DBType.FLOAT);
+ colH = new ColSpec("colH", DBType.DOUBLE);
+ colI = new ColSpec("colI", DBType.DECIMAL, 3, 5, false);
+ colJ = new ColSpec("colJ", DBType.TIMESTAMP,true);
+ colK = new ColSpec("colK", DBType.OBJECT);
+ cols = new ColSpec[]{ colA, colB, colC, colD, colE};
+
+ data = new Object[][] {
+ { "str1", 254, (short)355, 921124432352L,
+ true, 0x44, 3.1415f, 9.994d,
+ new BigDecimal(4.45), Calendar.getInstance(), null },
+ { "str2", -922, (short)9283, 1910382394511L,
+ true, 0x94, null, -0.994d,
+ new BigDecimal(-229444.452322), new Date(2005,04,02), colE },
+ { null, 011, (short)4242, 4992830402903L,
+ false, 0x4a, 9.95d, 0.0d,
+ new BigDecimal(0.0), null, null },
+ };
+
+ mrs = new MockResultSet(cols,data);
+ }
+
+ @AfterMethod(alwaysRun=true)
+ public void tearDown() throws Exception {
+ colA = colB = colC = colD = colE = null;
+ data = null;
+ mrs = null;
+ }
+
+ /** Should simply not throw an exception */
+ @Test
+ public void testResultSetCreationWithStrings() throws SQLException {
+ String[] cols2 = { "colA", "colB", "colC" };
+ mrs = new MockResultSet(cols2,data);
+ List<Row> dataMap = mrs.getData();
+ for (int i = 0; i < data.length ; i++) {
+ Row row = dataMap.get(i);
+ Assert.assertEquals(data[i][0], row.get("colA"));
+ Assert.assertEquals(data[i][1], row.get("colB"));
+ Assert.assertEquals(data[i][2], row.get("colC"));
+ }
+ }
+
+ @Test
+ public void testResultSetCreationWithNull() throws SQLException {
+ mrs = new MockResultSet(cols,null);
+ Assert.assertEquals(0,mrs.getData().size());
+ }
+
+ @Test
+ public void testResultSetAbsoluteNavigation() throws SQLException {
+ Assert.assertFalse(mrs.absolute(0));
+ Assert.assertTrue(mrs.absolute(1));
+ Assert.assertTrue(mrs.absolute(2));
+ Assert.assertTrue(mrs.absolute(3));
+ Assert.assertFalse(mrs.absolute(4));
+ Assert.assertFalse(mrs.absolute(5));
+
+ Assert.assertTrue(mrs.absolute(-1));
+ Assert.assertEquals(3,mrs.getRow());
+ Assert.assertTrue(mrs.absolute(-2));
+ Assert.assertEquals(2,mrs.getRow());
+ Assert.assertTrue(mrs.absolute(-3));
+ Assert.assertEquals(1,mrs.getRow());
+ Assert.assertFalse(mrs.absolute(-4));
+ Assert.assertEquals(0,mrs.getRow());
+ Assert.assertFalse(mrs.absolute(-5));
+ Assert.assertEquals(0,mrs.getRow());
+ Assert.assertTrue(mrs.isBeforeFirst());
+
+ Assert.assertEquals(0,mrs.getRow());
+ Assert.assertFalse(mrs.isAfterLast());
+ mrs.first();
+ Assert.assertEquals(1,mrs.getRow());
+ Assert.assertFalse(mrs.isBeforeFirst());
+ Assert.assertFalse(mrs.isAfterLast());
+ mrs.last();
+ Assert.assertEquals(3,mrs.getRow());
+ Assert.assertFalse(mrs.isBeforeFirst());
+ Assert.assertFalse(mrs.isAfterLast());
+ mrs.afterLast();
+ Assert.assertEquals(0,mrs.getRow());
+ Assert.assertFalse(mrs.isBeforeFirst());
+ Assert.assertTrue(mrs.isAfterLast());
+ }
+
+ @Test
+ public void testResultSetRelativeNavigation() throws SQLException {
+ mrs.beforeFirst();
+ Assert.assertTrue(mrs.isBeforeFirst());
+ Assert.assertTrue(mrs.next());
+ Assert.assertTrue(mrs.next());
+ Assert.assertTrue(mrs.next());
+ Assert.assertFalse(mrs.next());
+ Assert.assertTrue(mrs.isAfterLast());
+ Assert.assertTrue(mrs.previous());
+ Assert.assertTrue(mrs.previous());
+ Assert.assertTrue(mrs.previous());
+ Assert.assertFalse(mrs.previous());
+ Assert.assertTrue(mrs.isBeforeFirst());
+ }
+
+
+
+ /**
+ * Test each group of accessors depending on the type.
+ */
+ @Test
+ public void testResultSetGetOperations() throws Throwable {
+ String[] ptypes = { "java.lang.String", "int" };
+ Class<?>[][] classes = {
+ { Timestamp.class, Time.class, Date.class },
+ { short.class, long.class, int.class, float.class,
+ double.class, BigDecimal.class, boolean.class, byte.class },
+ { String.class },
+ { Object.class },
+ { byte[].class, Reader.class, Clob.class, Ref.class,
+ InputStream.class, InputStream.class, Array.class, Blob.class }
+ };
+ String[][] props = { { "Timestamp", "Time", "Date" },
+ { "Short", "Long", "Int", "Float",
+ "Double", "BigDecimal", "Boolean", "Byte" },
+ { "String" },
+ { "Object" },
+ { "Bytes", "CharacterStream", "Clob", "Ref",
+ "BinaryStream", "AsciiStream", "Array", "Blob" } };
+ mrs.beforeFirst();
+ System.out.println("Count:"+props.length);
+ while(mrs.next()) {
+ for (int colNo = 0 ; colNo < cols.length ; colNo++) {
+ ColSpec col = cols[colNo];
+ for (int i = 0; i < props[col.type.group.value].length ; i++) {
+ for (String ptype : ptypes) { // try both int and string column access
+ //System.out.println(col.name + ":col.type.group=" + col.type.group + "(" + col.type.group.value + ")" + ":method=get" + props[col.type.group.value][i] + "(" + ptype + "):data=" + data[mrs.getRow()-1][colNo] );
+ try {
+ // Do this the unsafe way so we don't use DynamicUtil and can avoid the dependency.
+ Method m = mrs.getClass().getMethod("get"+props[col.type.group.value][i],new Class[] { String.class });
+ Object obj = m.invoke(mrs, col.name );
+
+ Class<?> expectedClass = _boxedTypeEquivalents
+ .containsKey(classes[col.type.group.value][i]) ?
+ _boxedTypeEquivalents.get(classes[col.type.group.value][i]) :
+ classes[col.type.group.value][i];
+ Assert.assertEquals(expectedClass,obj.getClass());
+ Assert.assertTrue(expectedClass.isAssignableFrom(obj.getClass()));
+ } catch (ClassCastException e) {
+ //e.printStackTrace();
+ } catch (RuntimeException e) {
+ if (e.getCause() != null && !e.getCause().getClass().equals(ClassCastException.class)) throw e;
+ }
+
+ }
+ }
+ }
+ }
+ }
+ static Map<Class<?>, Class<?>> _boxedTypeEquivalents = new HashMap<Class<?>, Class<?>>();
+ static {
+ _boxedTypeEquivalents.put(boolean.class,Boolean.class);
+ _boxedTypeEquivalents.put(int.class,Integer.class);
+ _boxedTypeEquivalents.put(long.class,Long.class);
+ _boxedTypeEquivalents.put(short.class,Short.class);
+ _boxedTypeEquivalents.put(byte.class,Byte.class);
+ _boxedTypeEquivalents.put(char.class,Character.class);
+ _boxedTypeEquivalents.put(double.class,Double.class);
+ _boxedTypeEquivalents.put(float.class,Float.class);
+ }
+
+
+}
+
+
+
+
+
diff --git a/israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/RowTest.java b/israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/RowTest.java new file mode 100644 index 0000000..215a282 --- /dev/null +++ b/israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/RowTest.java @@ -0,0 +1,86 @@ +/*
+ * Copyright © 2003-2009 Israfil Consulting Services Corporation
+ * Copyright © 2003-2009 Christian Edward Gruber
+ * All Rights Reserved
+ *
+ * This software is licensed under the Berkeley Standard Distribution license,
+ * (BSD license), as defined below:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * 3. Neither the name of Israfil Consulting Services nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * $Id: RowTest.java 130 2006-12-31 23:22:17Z cgruber $
+ */
+package net.israfil.foundation.mock.sql;
+
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.List;
+
+import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+
+/**
+ *
+ * @author <a href="mailto:cgruber@israfil.net">Christian Edward Gruber </a>
+ * @author Latest: $Author: cgruber $
+ * @version $Revision: 130 $
+ */
+public class RowTest {
+
+ Row row;
+ String[] columns = { "ColumnA", "ColumnB", "ColumnC" };
+ MockResultSetMetaData rsmd = new MockResultSetMetaData(columns);
+ String valc = "Value C";
+ List<Object> data = Arrays.asList(new Object[] {"Value A", "Value B", null});
+
+ @BeforeMethod(alwaysRun=true)
+ public void setUp() throws Exception {
+ row = new Row(rsmd, data);
+ }
+
+ @AfterMethod(alwaysRun=true)
+ public void tearDown() throws Exception {
+ row = null;
+ }
+
+ /* Should simply not throw an exception */
+ public void testSetWithInt() throws SQLException {
+ Assert.assertEquals(null,row.get(3));
+ row.set(3,valc);
+ Assert.assertEquals(valc,row.get(3));
+ }
+
+ /* Should simply not throw an exception */
+ public void testSetWithString() throws SQLException {
+ Assert.assertEquals(null,row.get("ColumnC"));
+ row.set("ColumnC",valc);
+ Assert.assertEquals(valc,row.get("ColumnC"));
+ }
+}
+
+
+
+
+
|