public TesterResultSet(Statement stmt) 
{
        _statement = stmt;
}

 public TesterResultSet(Statement stmt,
    Object[][] data) 
{
        _statement = stmt;
        _data = data;
}

 public TesterResultSet(Statement stmt,
    Object[][] data,
    int type,
    int concurrency) 
{
        _statement = stmt;
        _data = data;
        _type = type;
        _concurrency = concurrency;
}

 public boolean absolute(int row) throws SQLException 
{
        checkOpen();
        return false;
}

 public  void afterLast() throws SQLException 
{
        checkOpen();
}

 public  void beforeFirst() throws SQLException 
{
        checkOpen();
}

 public  void cancelRowUpdates() throws SQLException 
{
        checkOpen();
}

 protected  void checkOpen() throws SQLException 
{
        if(!_open) {
            throw new SQLException("ResultSet is closed.");
        }
}

 public  void clearWarnings() throws SQLException 
{
        checkOpen();
}

 public  void close() throws SQLException 
{
        checkOpen();
        ((TesterStatement)_statement)._resultSet = null;
        _open = false;
}

 public  void deleteRow() throws SQLException 
{
        checkOpen();
}

 public int findColumn(String columnName) throws SQLException 
{
        checkOpen();
        return 1;
}

 public boolean first() throws SQLException 
{
        checkOpen();
        return false;
}

 public Array getArray(int i) throws SQLException 
{
        checkOpen();
        return null;
}

 public Array getArray(String colName) throws SQLException 
{
        checkOpen();
        return null;
}

 public InputStream getAsciiStream(int columnIndex) throws SQLException 
{
        checkOpen();
        return null;
}

 public InputStream getAsciiStream(String columnName) throws SQLException 
{
        checkOpen();
        return null;
}

 public BigDecimal getBigDecimal(int columnIndex) throws SQLException 
{
        checkOpen();
        return new BigDecimal((double)columnIndex);
}

 public BigDecimal getBigDecimal(String columnName) throws SQLException 
{
        checkOpen();
        return new BigDecimal((double)columnName.hashCode());
}

 public BigDecimal getBigDecimal(int columnIndex,
    int scale) throws SQLException 
{
        checkOpen();
        return new BigDecimal((double)columnIndex);
}

 public BigDecimal getBigDecimal(String columnName,
    int scale) throws SQLException 
{
        checkOpen();
        return new BigDecimal((double)columnName.hashCode());
}

 public InputStream getBinaryStream(int columnIndex) throws SQLException 
{
        checkOpen();
        return null;
}

 public InputStream getBinaryStream(String columnName) throws SQLException 
{
        checkOpen();
        return null;
}

 public Blob getBlob(int i) throws SQLException 
{
        checkOpen();
        return null;
}

 public Blob getBlob(String colName) throws SQLException 
{
        checkOpen();
        return null;
}

 public boolean getBoolean(int columnIndex) throws SQLException 
{
        checkOpen();
        return true;
}

 public boolean getBoolean(String columnName) throws SQLException 
{
        checkOpen();
        return true;
}

 public byte getByte(int columnIndex) throws SQLException 
{
        checkOpen();
        return (byte)columnIndex;
}

 public byte getByte(String columnName) throws SQLException 
{
        checkOpen();
        return (byte)(columnName.hashCode());
}

 public byte[] getBytes(int columnIndex) throws SQLException 
{
        checkOpen();
        return new byte[] { (byte)columnIndex };
}

 public byte[] getBytes(String columnName) throws SQLException 
{
        checkOpen();
        return columnName.getBytes();
}

 public Reader getCharacterStream(int columnIndex) throws SQLException 
{
        checkOpen();
        return null;
}

 public Reader getCharacterStream(String columnName) throws SQLException 
{
        checkOpen();
        return null;
}

 public Clob getClob(int i) throws SQLException 
{
        checkOpen();
        return null;
}

 public Clob getClob(String colName) throws SQLException 
{
        checkOpen();
        return null;
}

 public int getConcurrency() throws SQLException 
{
        return this._concurrency;
}

 public String getCursorName() throws SQLException 
{
        checkOpen();
        return null;
}

 public Date getDate(int columnIndex) throws SQLException 
{
        checkOpen();
        return null;
}

 public Date getDate(String columnName) throws SQLException 
{
        checkOpen();
        return null;
}

 public Date getDate(int columnIndex,
    Calendar cal) throws SQLException 
{
        checkOpen();
        return null;
}

 public Date getDate(String columnName,
    Calendar cal) throws SQLException 
{
        checkOpen();
        return null;
}

 public double getDouble(int columnIndex) throws SQLException 
{
        checkOpen();
        return (double)columnIndex;
}

 public double getDouble(String columnName) throws SQLException 
{
        checkOpen();
        return (double)(columnName.hashCode());
}

 public int getFetchDirection() throws SQLException 
{
        checkOpen();
        return 1;
}

 public int getFetchSize() throws SQLException 
{
        checkOpen();
        return 2;
}

 public float getFloat(int columnIndex) throws SQLException 
{
        checkOpen();
        return (float)columnIndex;
}

 public float getFloat(String columnName) throws SQLException 
{
        checkOpen();
        return (float)(columnName.hashCode());
}

 public int getInt(int columnIndex) throws SQLException 
{
        checkOpen();
        return (short)columnIndex;
}

 public int getInt(String columnName) throws SQLException 
{
        checkOpen();
        return (columnName.hashCode());
}

 public long getLong(int columnIndex) throws SQLException 
{
        checkOpen();
        return (long)columnIndex;
}

 public long getLong(String columnName) throws SQLException 
{
        checkOpen();
        return (long)(columnName.hashCode());
}

 public ResultSetMetaData getMetaData() throws SQLException 
{
        checkOpen();
        return null;
}

 public Object getObject(int columnIndex) throws SQLException 
{
        checkOpen();
        if (_data != null) {
            return _data[_currentRow][columnIndex-1];
        }
        return new Object();
}

 public Object getObject(String columnName) throws SQLException 
{
        checkOpen();
        return columnName;
}

 public Object getObject(int i,
    Map map) throws SQLException 
{
        checkOpen();
        return new Object();
}

 public Object getObject(String colName,
    Map map) throws SQLException 
{
        checkOpen();
        return colName;
}

 public Ref getRef(int i) throws SQLException 
{
        checkOpen();
        return null;
}

 public Ref getRef(String colName) throws SQLException 
{
        checkOpen();
        return null;
}

 public int getRow() throws SQLException 
{
        checkOpen();
        return 3 - _rowsLeft;
}

 public short getShort(int columnIndex) throws SQLException 
{
        checkOpen();
        return (short)columnIndex;
}

 public short getShort(String columnName) throws SQLException 
{
        checkOpen();
        return (short)(columnName.hashCode());
}

 public Statement getStatement() throws SQLException 
{
        checkOpen();
        return _statement;
}

 public String getString(int columnIndex) throws SQLException 
{
        checkOpen();
        if (columnIndex == -1) {
            throw new SQLException("broken connection");
        }
        if (_data != null) {
            return (String) getObject(columnIndex);
        }
        return "String" + columnIndex;
}

 public String getString(String columnName) throws SQLException 
{
        checkOpen();
        return columnName;
}

 public Time getTime(int columnIndex) throws SQLException 
{
        checkOpen();
        return null;
}

 public Time getTime(String columnName) throws SQLException 
{
        checkOpen();
        return null;
}

 public Time getTime(int columnIndex,
    Calendar cal) throws SQLException 
{
        checkOpen();
        return null;
}

 public Time getTime(String columnName,
    Calendar cal) throws SQLException 
{
        checkOpen();
        return null;
}

 public Timestamp getTimestamp(int columnIndex) throws SQLException 
{
        checkOpen();
        return null;
}

 public Timestamp getTimestamp(String columnName) throws SQLException 
{
        checkOpen();
        return null;
}

 public Timestamp getTimestamp(int columnIndex,
    Calendar cal) throws SQLException 
{
        checkOpen();
        return null;
}

 public Timestamp getTimestamp(String columnName,
    Calendar cal) throws SQLException 
{
        checkOpen();
        return null;
}

 public int getType() throws SQLException 
{
        return this._type;
}

 public URL getURL(int columnIndex) throws SQLException 
{
        throw new SQLException("Not implemented.");
}

 public URL getURL(String columnName) throws SQLException 
{
        throw new SQLException("Not implemented.");
}

 public InputStream getUnicodeStream(int columnIndex) throws SQLException 
{
        checkOpen();
        return null;
}

 public InputStream getUnicodeStream(String columnName) throws SQLException 
{
        checkOpen();
        return null;
}

 public SQLWarning getWarnings() throws SQLException 
{
       checkOpen();
       return null;
}

 public  void insertRow() throws SQLException 
{
        checkOpen();
}

 public boolean isAfterLast() throws SQLException 
{
        checkOpen();
        return _rowsLeft <  0;
}

 public boolean isBeforeFirst() throws SQLException 
{
        checkOpen();
        return _rowsLeft == 2;
}

 public boolean isFirst() throws SQLException 
{
        checkOpen();
        return _rowsLeft == 1;
}

 public boolean isLast() throws SQLException 
{
        checkOpen();
        return _rowsLeft == 0;
}

 public boolean last() throws SQLException 
{
        checkOpen();
        return false;
}

 public  void moveToCurrentRow() throws SQLException 
{
        checkOpen();
}

 public  void moveToInsertRow() throws SQLException 
{
        checkOpen();
}

 public boolean next() throws SQLException 
{
         
        checkOpen();
        if (_data != null) {
            _currentRow++;
            return _currentRow <  _data.length;
        }
        else {
            if(--_rowsLeft  > 0) {
                return true;
            } else {
                return false;
            }
        }
}

 public boolean previous() throws SQLException 
{
        checkOpen();
        return false;
}

 public  void refreshRow() throws SQLException 
{
        checkOpen();
}

 public boolean relative(int rows) throws SQLException 
{
        checkOpen();
        return false;
}

 public boolean rowDeleted() throws SQLException 
{
        checkOpen();
        return false;
}

 public boolean rowInserted() throws SQLException 
{
        checkOpen();
        return false;
}

 public boolean rowUpdated() throws SQLException 
{
        checkOpen();
        return false;
}

 public  void setFetchDirection(int direction) throws SQLException 
{
        checkOpen();
}

 public  void setFetchSize(int rows) throws SQLException 
{
        checkOpen();
}

 public  void updateArray(int columnIndex,
    Array x) throws SQLException 
{
        throw new SQLException("Not implemented.");
}

 public  void updateArray(String columnName,
    Array x) throws SQLException 
{
        throw new SQLException("Not implemented.");
}

 public  void updateAsciiStream(int columnIndex,
    InputStream x,
    int length) throws SQLException 
{
        checkOpen();
}

 public  void updateAsciiStream(String columnName,
    InputStream x,
    int length) throws SQLException 
{
        checkOpen();
}

 public  void updateBigDecimal(int columnIndex,
    BigDecimal x) throws SQLException 
{
        checkOpen();
}

 public  void updateBigDecimal(String columnName,
    BigDecimal x) throws SQLException 
{
        checkOpen();
}

 public  void updateBinaryStream(int columnIndex,
    InputStream x,
    int length) throws SQLException 
{
        checkOpen();
}

 public  void updateBinaryStream(String columnName,
    InputStream x,
    int length) throws SQLException 
{
        checkOpen();
}

 public  void updateBlob(int columnIndex,
    Blob x) throws SQLException 
{
        throw new SQLException("Not implemented.");
}

 public  void updateBlob(String columnName,
    Blob x) throws SQLException 
{
        throw new SQLException("Not implemented.");
}

 public  void updateBoolean(int columnIndex,
    boolean x) throws SQLException 
{
        checkOpen();
}

 public  void updateBoolean(String columnName,
    boolean x) throws SQLException 
{
        checkOpen();
}

 public  void updateByte(int columnIndex,
    byte x) throws SQLException 
{
        checkOpen();
}

 public  void updateByte(String columnName,
    byte x) throws SQLException 
{
        checkOpen();
}

 public  void updateBytes(int columnIndex,
    byte[] x) throws SQLException 
{
        checkOpen();
}

 public  void updateBytes(String columnName,
    byte[] x) throws SQLException 
{
        checkOpen();
}

 public  void updateCharacterStream(int columnIndex,
    Reader x,
    int length) throws SQLException 
{
        checkOpen();
}

 public  void updateCharacterStream(String columnName,
    Reader reader,
    int length) throws SQLException 
{
        checkOpen();
}

 public  void updateClob(int columnIndex,
    Clob x) throws SQLException 
{
        throw new SQLException("Not implemented.");
}

 public  void updateClob(String columnName,
    Clob x) throws SQLException 
{
        throw new SQLException("Not implemented.");
}

 public  void updateDate(int columnIndex,
    Date x) throws SQLException 
{
        checkOpen();
}

 public  void updateDate(String columnName,
    Date x) throws SQLException 
{
        checkOpen();
}

 public  void updateDouble(int columnIndex,
    double x) throws SQLException 
{
        checkOpen();
}

 public  void updateDouble(String columnName,
    double x) throws SQLException 
{
        checkOpen();
}

 public  void updateFloat(int columnIndex,
    float x) throws SQLException 
{
        checkOpen();
}

 public  void updateFloat(String columnName,
    float x) throws SQLException 
{
        checkOpen();
}

 public  void updateInt(int columnIndex,
    int x) throws SQLException 
{
        checkOpen();
}

 public  void updateInt(String columnName,
    int x) throws SQLException 
{
        checkOpen();
}

 public  void updateLong(int columnIndex,
    long x) throws SQLException 
{
        checkOpen();
}

 public  void updateLong(String columnName,
    long x) throws SQLException 
{
        checkOpen();
}

 public  void updateNull(int columnIndex) throws SQLException 
{
        checkOpen();
}

 public  void updateNull(String columnName) throws SQLException 
{
        checkOpen();
}

 public  void updateObject(int columnIndex,
    Object x) throws SQLException 
{
        checkOpen();
}

 public  void updateObject(String columnName,
    Object x) throws SQLException 
{
        checkOpen();
}

 public  void updateObject(int columnIndex,
    Object x,
    int scale) throws SQLException 
{
        checkOpen();
}

 public  void updateObject(String columnName,
    Object x,
    int scale) throws SQLException 
{
        checkOpen();
}

 public  void updateRef(int columnIndex,
    Ref x) throws SQLException 
{
        throw new SQLException("Not implemented.");
}

 public  void updateRef(String columnName,
    Ref x) throws SQLException 
{
        throw new SQLException("Not implemented.");
}

 public  void updateRow() throws SQLException 
{
        checkOpen();
}

 public  void updateShort(int columnIndex,
    short x) throws SQLException 
{
        checkOpen();
}

 public  void updateShort(String columnName,
    short x) throws SQLException 
{
        checkOpen();
}

 public  void updateString(int columnIndex,
    String x) throws SQLException 
{
        checkOpen();
}

 public  void updateString(String columnName,
    String x) throws SQLException 
{
        checkOpen();
}

 public  void updateTime(int columnIndex,
    Time x) throws SQLException 
{
        checkOpen();
}

 public  void updateTime(String columnName,
    Time x) throws SQLException 
{
        checkOpen();
}

 public  void updateTimestamp(int columnIndex,
    Timestamp x) throws SQLException 
{
        checkOpen();
}

 public  void updateTimestamp(String columnName,
    Timestamp x) throws SQLException 
{
        checkOpen();
}

 public boolean wasNull() throws SQLException 
{
        checkOpen();
        return false;
}