From 7c279747beb43c7e88633a6228a155a30e6834f7 Mon Sep 17 00:00:00 2001 From: Benjamin Culkin Date: Mon, 27 May 2024 11:38:33 -0400 Subject: Initial import --- .../israfil/foundation/mock/sql/MockResultSet.java | 1350 ++++++++++++++++++++ .../foundation/mock/sql/MockResultSetMetaData.java | 342 +++++ .../java/net/israfil/foundation/mock/sql/Row.java | 98 ++ .../mock/sql/MockResultSetMetaDataTest.java | 113 ++ .../foundation/mock/sql/MockResultSetTest.java | 263 ++++ .../net/israfil/foundation/mock/sql/RowTest.java | 86 ++ 6 files changed, 2252 insertions(+) create mode 100644 israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/MockResultSet.java create mode 100644 israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/MockResultSetMetaData.java create mode 100644 israfil-foundation-testing/src/main/java/net/israfil/foundation/mock/sql/Row.java create mode 100644 israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/MockResultSetMetaDataTest.java create mode 100644 israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/MockResultSetTest.java create mode 100644 israfil-foundation-testing/src/test/java/net/israfil/foundation/mock/sql/RowTest.java (limited to 'israfil-foundation-testing/src') 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 Christian Edward Gruber + */ +public class MockResultSet implements ResultSet { + + public MockResultSetMetaData metadata; + + protected List data; + public List 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(metadata.getColumnCount()); + for (int rowNum = 0; rowNum < rows.length; rowNum++) { + data.add(new Row(metadata,new ArrayList(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> 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> 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 unwrap(Class 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 getObject(int columnIndex, Class type) throws SQLException { + // TODO Auto-generated method stub + return null; + } + + @Override + public T getObject(String columnLabel, Class 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 Christian Edward Gruber + */ +public class MockResultSetMetaData implements ResultSetMetaData { + + public static int ZERO_ORDER_LIST_OFFSET = 1; + List 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(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 unwrap(Class 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 Christian Edward Gruber + */ +public class Row { + + MockResultSetMetaData metadata = null; + List data; + + int cursorPosition; + final boolean insertRow; + public boolean dirty = true; + + public Row(MockResultSetMetaData metadata, List rowData) { + this(metadata,rowData,false); + } + + public Row(MockResultSetMetaData metadata, List 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 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 Christian Edward Gruber + * @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 Christian Edward Gruber + * @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 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> _boxedTypeEquivalents = new HashMap, 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 Christian Edward Gruber + * @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 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")); + } +} + + + + + -- cgit v1.2.3