[Mockobjects-java-users] MockPreparedStatement (JDBC 3.0 Complaint)

[Verma, N. (C. G. L529706) <Nit...@ge...>]

package com.mockobjects.sql;

import java.math.BigDecimal;
import java.util.Calendar;
import java.sql.*;
import com.mockobjects.ExpectationCounter;
import com.mockobjects.ExpectationSet;
import com.mockobjects.MapEntry;
import junit.framework.AssertionFailedError;


/**
 * Trial version
 * @author Nitin Verma
 * @version 1.0 24 Dec 2001
 */

public class MockPreparedStatement extends MockStatement implements
PreparedStatement{
	
	/* Nested MockObjects */
	
	/*Expectations objects that can be set */
	
    private ExpectationSet mySetParameters = new
ExpectationSet("MockPreparedStatement.setParameters");
    private ExpectationCounter myclearParametersCalls = new
ExpectationCounter("MockPreparedStatement.clearParameters() calls");	
	
	/*Other objects*/
	
	ParameterMetaData myparameterMetaData;
	
	/* Methods for mockobject's internal use only */
	
	/* Methods wrapped*/
	
    public MockPreparedStatement() {

        super();
    }
    
    public void clearParameters() throws SQLException {
        myclearParametersCalls.inc();
    }

    public boolean execute() throws SQLException {
    	return execute("");
    }
    
    public ResultSet executeQuery() throws SQLException {
        return executeQuery("");
    }

    public int executeUpdate() throws SQLException {
        return executeUpdate("");
    }

    public void setInt(int parameterIndex, int x) throws SQLException {
        setObject(parameterIndex, new Integer(x));
    }

    public void setString(int parameterIndex, String x) throws SQLException
{
        setObject(parameterIndex, x);
    }

    public void setTimestamp(int param, Timestamp timestamp) throws
SQLException {
        setObject(param, timestamp);
    }

    public void setClob(int param, Clob clob) throws SQLException {
        setObject(param, clob);
    }

    public void setLong(int param, long aLong) throws SQLException {
        setObject(param, new Long(aLong));
    }

    public void addBatch() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void setNull(int param, int param1) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void setArray(int param, Array array) throws SQLException {
        setObject(param, array);
    }

    public void setShort(int param, short aShort) throws SQLException {
        setObject(param, new Short(aShort));
    }

    public void setTime(int param, Time time, Calendar calendar) throws
SQLException {
        setObject(param, time);
    }

    public void setObject(int param, Object obj, int targetSqlType, int
scale) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void setObject(int param, Object obj, int targetSqlType) throws
SQLException {
        throw new UnsupportedOperationException();
    }

    public void setRef(int param, Ref ref) throws SQLException {
        setObject(param, ref);
    }

    public void setDate(int param, Date date) throws SQLException {
        setObject(param, date);
    }

    public void setFloat(int param, float aFloat) throws SQLException {
        setObject(param, new Float(aFloat));
    }

    public void setBlob(int param, Blob blob) throws SQLException {
        setObject(param, blob);
    }

    public void setCharacterStream(int param, java.io.Reader reader, int
length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void setAsciiStream(int param, java.io.InputStream inputStream,
int length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void setDate(int param, Date date, Calendar calendar) throws
SQLException {
        setDate(param, date);
    }

    public void setBinaryStream(int param, java.io.InputStream inputStream,
int length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void setUnicodeStream(int param, java.io.InputStream inputStream,
int length) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void setBytes(int param, byte[] values) throws SQLException {
        setObject(param, values);
    }

    public void setObject(int param, Object obj) throws SQLException {
        mySetParameters.addActual(new MapEntry(new Integer(param), obj));
    }

    public void setByte(int param, byte aByte) throws SQLException {
        setObject(param, new Byte(aByte));
    }

    public void setDouble(int param, double aDouble) throws SQLException {
        setObject(param, new Double(aDouble));
    }

    public ResultSetMetaData getMetaData() throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void setTimestamp(int param, Timestamp timestamp, Calendar
calendar) throws SQLException {
        throw new UnsupportedOperationException();
    }

    public void setTime(int param, Time time) throws SQLException {
        setObject(param, time);
    }

    public void setBoolean(int param, boolean aBoolean) throws SQLException
{
        setObject(param, new Boolean(aBoolean));
    }

    public void setNull(int param, int param1, String typeName) throws
SQLException {
        throw new UnsupportedOperationException();
    }

    public void setBigDecimal(int param, BigDecimal bigDecimal) throws
SQLException {
        setObject(param, bigDecimal);
    }        

    //------------------------- JDBC 3.0 -----------------------------------
 
    public void setURL(int parameterIndex, java.net.URL p_url) throws
SQLException{
    	setObject(parameterIndex, p_url);
    }

    public ParameterMetaData getParameterMetaData() throws SQLException{
throw new AssertionFailedError("Not Implemented"); }
    
    /* Methods only to be called inside test classes */
    
    public void addExpectedSetParameter(int p_parameterIndex, boolean
p_value) {
        addExpectedSetParameter(p_parameterIndex, new Boolean(p_value));
    }    

    public void addExpectedSetParameter(int p_parameterIndex, byte p_value)
{
        addExpectedSetParameter(p_parameterIndex, new Byte(p_value));
    }
    
    public void addExpectedSetParameter(int p_parameterIndex, char p_value)
{
        addExpectedSetParameter(p_parameterIndex, new Character(p_value));
    }

    public void addExpectedSetParameter(int p_parameterIndex, short p_value)
{
        addExpectedSetParameter(p_parameterIndex, new Short(p_value));
    }
    
    public void addExpectedSetParameter(int p_parameterIndex, int p_value) {
        addExpectedSetParameter(p_parameterIndex, new Integer(p_value));
    }    

    public void addExpectedSetParameter(int p_parameterIndex, long p_value)
{
        addExpectedSetParameter(p_parameterIndex, new Long(p_value));
    }

    public void addExpectedSetParameter(int p_parameterIndex, float p_value)
{
        addExpectedSetParameter(p_parameterIndex, new Float(p_value));
    }    

    public void addExpectedSetParameter(int p_parameterIndex, double
p_value) {
        addExpectedSetParameter(p_parameterIndex, new Double(p_value));
    }    
    
    public void addExpectedSetParameter(int parameterIndex, Object
parameterValue) {
        mySetParameters.addExpected(new MapEntry(new
Integer(parameterIndex), parameterValue));
    }

    public void addExpectedSetParameters(Object[] parameters) {
        for (int i = 0; i < parameters.length; ++i) {
            addExpectedSetParameter(i + 1, parameters[i]);
        }
    }
    
    public void setExpectedClearParametersCalls(int callCount) {
        myclearParametersCalls.setExpected(callCount);
    }

    public void setExpectingNoSetParameters() {
        mySetParameters.setExpectNothing();
    }
    
    
    public void setupParameterMetaData(ParameterMetaData
p_parameterMetaData){
    	myparameterMetaData = p_parameterMetaData;
    }
    

}


"THIS E-MAIL MESSAGE ALONG WITH ANY ATTACHMENTS IS INTENDED ONLY FOR THE
ADDRESSEE and may contain confidential and privileged information.
If the reader of this message is not the intended recipient,
you are notified that any dissemination, distribution or copy of this 
communication is strictly Prohibited. 
If you have received this message by error, please notify us 
immediately, return the original mail to the sender and delete the 
message from your system."