[Mockobjects-java-users] MockCallableStatement (JDBC 3.0 Complaint)--Nitin Verma

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

package com.mockobjects.sql;

import java.math.BigDecimal;
import java.util.Calendar;
import java.sql.*;
import com.mockobjects.util.NotImplementedException;
import com.mockobjects.ExpectationValue;
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 MockCallableStatement extends MockPreparedStatement implements
CallableStatement {

	/* Nested MockObjects */

	/*Expectations objects that can be set */
	private ExpectationSet myRegisterOutParameters = new
ExpectationSet("MockCallableStatement.myRegisterOutParameters");
	private ExpectationSet myRegisterOutParametersName = new
ExpectationSet("MockCallableStatement.myRegisterOutParameters(parameterName)
");
	private ExpectationValue myCalendarObject = new
ExpectationValue("MockCallableStatement.calendar");

	/*Other objects*/

	/* Methods for mockobject's internal use only */

	/* Methods wrapped*/

    public void registerOutParameter(int parameterIndex, int sqlType)
	throws SQLException{
		myRegisterOutParameters.addActual(new MapEntry(new
Integer(parameterIndex),new OutParameter(new Integer(sqlType))));
	}

    public void registerOutParameter(int parameterIndex, int sqlType, int
scale)
	throws SQLException{
		myRegisterOutParameters.addActual(new MapEntry(new
Integer(parameterIndex),new OutParameter(new Integer(sqlType),new
Integer(scale))));
	}

    public boolean wasNull() throws SQLException{
    	throw new AssertionFailedError("Not Implemented");
    }

    public String getString(int parameterIndex) throws SQLException{
    	return myResultSet.getString(parameterIndex);
    }

    public boolean getBoolean(int parameterIndex) throws SQLException{
    	return myResultSet.getBoolean(parameterIndex);
    }

    public byte getByte(int parameterIndex) throws SQLException{
    	return myResultSet.getByte(parameterIndex); 
    }

    public short getShort(int parameterIndex) throws SQLException{
    	return myResultSet.getShort(parameterIndex);
    }

    public int getInt(int parameterIndex) throws SQLException{
    	return myResultSet.getInt(parameterIndex);
    }

    public long getLong(int parameterIndex) throws SQLException{
    	return myResultSet.getLong(parameterIndex);
    }

    public float getFloat(int parameterIndex) throws SQLException{
    	return myResultSet.getFloat(parameterIndex);
    }

    public double getDouble(int parameterIndex) throws SQLException{
    	return myResultSet.getDouble(parameterIndex);
    }

    public BigDecimal getBigDecimal(int parameterIndex, int scale)
	throws SQLException{
		return myResultSet.getBigDecimal(parameterIndex);
	}

    public byte[] getBytes(int parameterIndex) throws SQLException{
    	return myResultSet.getBytes(parameterIndex);
    }

    public java.sql.Date getDate(int parameterIndex) throws SQLException{
    	return myResultSet.getDate(parameterIndex);
    }

    public java.sql.Time getTime(int parameterIndex) throws SQLException{
    	return myResultSet.getTime(parameterIndex);
    }

    public java.sql.Timestamp getTimestamp(int parameterIndex) 
	throws SQLException{
		return myResultSet.getTimestamp(parameterIndex);
	}

    public Object getObject(int parameterIndex) throws SQLException{
    	return myResultSet.getObject(parameterIndex);
    }

    //--------------------------JDBC 2.0-----------------------------

    public BigDecimal getBigDecimal(int parameterIndex) throws SQLException{
    	return myResultSet.getBigDecimal(parameterIndex);
    }

    public Object  getObject(int i, java.util.Map map) throws SQLException{
    	throw new AssertionFailedError("Not Implemented");
    }

    public Ref getRef(int parameterIndex) throws SQLException{
    	return myResultSet.getRef(parameterIndex);
    }

    public Blob getBlob(int parameterIndex) throws SQLException{
    	return myResultSet.getBlob(parameterIndex);
    }

    public Clob getClob(int parameterIndex) throws SQLException{
    	return myResultSet.getClob(parameterIndex);
    }

    public Array getArray (int parameterIndex) throws SQLException{
    	return myResultSet.getArray(parameterIndex);
    }

    public java.sql.Date getDate(int parameterIndex, Calendar cal) 
	throws SQLException{ 
		return myResultSet.getDate(parameterIndex);
	}

    public java.sql.Time getTime(int parameterIndex, Calendar cal) 
	throws SQLException{
		return myResultSet.getTime(parameterIndex);
	}

    public java.sql.Timestamp getTimestamp(int parameterIndex, Calendar cal)

	throws SQLException{
		return myResultSet.getTimestamp(parameterIndex);
	}

    public void registerOutParameter (int parameterIndex, int sqlType,
String typeName)
	throws SQLException{
		myRegisterOutParameters.addActual(new MapEntry(new
Integer(parameterIndex),new OutParameter(new Integer(sqlType),typeName)));
	}

  //--------------------------JDBC 3.0-----------------------------

    public void registerOutParameter(String parameterName, int sqlType)
	throws SQLException{
		myRegisterOutParametersName.addActual(new
MapEntry(parameterName,new OutParameter(new Integer(sqlType))));
	}

    public void registerOutParameter(String parameterName, int sqlType, int
scale)
	throws SQLException{
		myRegisterOutParametersName.addActual(new
MapEntry(parameterName,new OutParameter(new Integer(sqlType),new
Integer(scale))));
	}

    public void registerOutParameter (String parameterName, int sqlType,
String typeName)
	throws SQLException{
		myRegisterOutParametersName.addActual(new
MapEntry(parameterName,new OutParameter(new Integer(sqlType),typeName)));
	}

    public java.net.URL getURL(int parameterIndex) throws SQLException{ 
    	return myResultSet.getURL(parameterIndex);
    }

    public void setURL(String parameterName, java.net.URL val) throws
SQLException{ throw new AssertionFailedError("Not Implemented"); }

    public void setNull(String parameterName, int sqlType) throws
SQLException{ throw new AssertionFailedError("Not Implemented"); }

    public void setBoolean(String parameterName, boolean x) throws
SQLException{ throw new AssertionFailedError("Not Implemented"); }

    public void setByte(String parameterName, byte x) throws SQLException{
throw new AssertionFailedError("Not Implemented"); }

    public void setShort(String parameterName, short x) throws SQLException{
throw new AssertionFailedError("Not Implemented"); }

    public void setInt(String parameterName, int x) throws SQLException{
throw new AssertionFailedError("Not Implemented"); }

    public void setLong(String parameterName, long x) throws SQLException{
throw new AssertionFailedError("Not Implemented"); }

    public void setFloat(String parameterName, float x) throws SQLException{
throw new AssertionFailedError("Not Implemented"); }

    public void setDouble(String parameterName, double x) throws
SQLException{ throw new AssertionFailedError("Not Implemented"); }

    public void setBigDecimal(String parameterName, BigDecimal x) throws
SQLException{ throw new AssertionFailedError("Not Implemented"); }

    public void setString(String parameterName, String x) throws
SQLException{ throw new AssertionFailedError("Not Implemented"); }

    public void setBytes(String parameterName, byte x[]) throws
SQLException{ throw new AssertionFailedError("Not Implemented"); }

    public void setDate(String parameterName, java.sql.Date x)
	throws SQLException{ throw new AssertionFailedError("Not
Implemented"); }

    public void setTime(String parameterName, java.sql.Time x) 
	throws SQLException{ throw new AssertionFailedError("Not
Implemented"); }

    public void setTimestamp(String parameterName, java.sql.Timestamp x)
	throws SQLException{ throw new AssertionFailedError("Not
Implemented"); }

    public void setAsciiStream(String parameterName, java.io.InputStream x,
int length)
	throws SQLException{ throw new AssertionFailedError("Not
Implemented"); }

    public void setBinaryStream(String parameterName, java.io.InputStream x,

			 int length) throws SQLException{ throw new
AssertionFailedError("Not Implemented"); }

    public void setObject(String parameterName, Object x, int targetSqlType,
int scale)
	throws SQLException{ throw new AssertionFailedError("Not
Implemented"); }

    public void setObject(String parameterName, Object x, int targetSqlType)

	throws SQLException{ throw new AssertionFailedError("Not
Implemented"); }

    public void setObject(String parameterName, Object x) throws
SQLException{ throw new AssertionFailedError("Not Implemented"); }

    public void setCharacterStream(String parameterName,
			    java.io.Reader reader,
			    int length) throws SQLException{ throw new
AssertionFailedError("Not Implemented"); }

    public void setDate(String parameterName, java.sql.Date x, Calendar cal)
	throws SQLException{ throw new AssertionFailedError("Not
Implemented"); }

    public void setTime(String parameterName, java.sql.Time x, Calendar cal)

	throws SQLException{ throw new AssertionFailedError("Not
Implemented"); }

    public void setTimestamp(String parameterName, java.sql.Timestamp x,
Calendar cal)
	throws SQLException{ throw new AssertionFailedError("Not
Implemented"); }

    public String getString(String parameterName) throws SQLException{
    	return myResultSet.getString(parameterName);
    }

    public boolean getBoolean(String parameterName) throws SQLException{
    	return myResultSet.getBoolean(parameterName);
    }

    public byte getByte(String parameterName) throws SQLException{
    	return myResultSet.getByte(parameterName);
    }

    public short getShort(String parameterName) throws SQLException{
    	return myResultSet.getShort(parameterName);
    }

    public int getInt(String parameterName) throws SQLException{
    	return myResultSet.getInt(parameterName);
    }

    public long getLong(String parameterName) throws SQLException{
    	return myResultSet.getLong(parameterName); 
    }

    public float getFloat(String parameterName) throws SQLException{
    	return myResultSet.getFloat(parameterName);
    }

    public double getDouble(String parameterName) throws SQLException{
    	return myResultSet.getDouble(parameterName);
    }

    public byte[] getBytes(String parameterName) throws SQLException{
    	return myResultSet.getBytes(parameterName);
    }

    public java.sql.Date getDate(String parameterName) throws SQLException{
    	return myResultSet.getDate(parameterName);
    }

    public java.sql.Time getTime(String parameterName) throws SQLException{
    	return myResultSet.getTime(parameterName);
    }

    public java.sql.Timestamp getTimestamp(String parameterName) throws
SQLException{
    	return myResultSet.getTimestamp(parameterName);
    }

    public Object getObject(String parameterName) throws SQLException{
    	return myResultSet.getObject(parameterName);
    }

    public BigDecimal getBigDecimal(String parameterName) throws
SQLException{
    	return myResultSet.getBigDecimal(parameterName);
    }

    public Object  getObject (String parameterName, java.util.Map map)
throws SQLException{
    	throw new AssertionFailedError("Not Implemented");
    }

    public Ref getRef(String parameterName) throws SQLException{
    	return myResultSet.getRef(parameterName);
    }

    public Blob getBlob(String parameterName) throws SQLException{
    	return myResultSet.getBlob(parameterName);
    }

    public Clob getClob(String parameterName) throws SQLException{
    	return myResultSet.getClob(parameterName);
    }

    public Array getArray(String parameterName) throws SQLException{
    	return myResultSet.getArray(parameterName);
    }

    public java.sql.Date getDate(String parameterName, Calendar cal) 
	throws SQLException{
		myCalendarObject.setActual(cal);
		return myResultSet.getDate(parameterName);
	}

    public java.sql.Time getTime(String parameterName, Calendar cal) 
	throws SQLException{
		myCalendarObject.setActual(cal);
		return myResultSet.getTime(parameterName);
	}

    public java.sql.Timestamp getTimestamp(String parameterName, Calendar
cal) 
	throws SQLException{
		myCalendarObject.setActual(cal);
		return myResultSet.getTimestamp(parameterName);
	}

    public java.net.URL getURL(String parameterName) throws SQLException{
    	return myResultSet.getURL(parameterName);
   	}

    /* Methods only to be called inside test classes */

    public void setupCalendarObject(Calendar p_calendar){
    	myCalendarObject.setExpected(p_calendar);
    }

    public void addExpectedRegisterOutParameter(int parameterIndex,
OutParameter parameterValue) {
        myRegisterOutParameters.addExpected(new MapEntry(new
Integer(parameterIndex), parameterValue));
    }

    public void addExpectedRegisterOutParameters(OutParameter[] parameters)
{
        for (int i = 0; i < parameters.length; ++i) {
            addExpectedSetParameter(i + 1, parameters[i]);
        }
    }

    public void addExpectedRegisterOutParameterName(String parameterName,
OutParameter parameterValue) {
        myRegisterOutParametersName.addExpected(new MapEntry(parameterName,
parameterValue));
    }

}

class OutParameter{
	private Integer mySqlType;
	private Integer myScale;
	private String myTypeName;

	public OutParameter(Integer p_sqlType, Integer p_scale){
		this(p_sqlType,null,p_scale);
	}

	public OutParameter(Integer p_sqlType){
		this(p_sqlType,null,null);
	}	

	public OutParameter(Integer p_sqlType, String p_typeName){
		this(p_sqlType,p_typeName,null);
	}

	private OutParameter(Integer p_sqlType, String p_typeName, Integer
p_scale){
		mySqlType = p_sqlType;
		myTypeName = p_typeName;
		myScale = p_scale;
	}

	public Integer getSqlType(){
		return mySqlType;
	}

	public String getTypeName(){
		return myTypeName;
	}

	public Integer getScale(){
		return myScale;
	}

	public boolean equals(Object obj){
		if(obj instanceof com.mockobjects.sql.OutParameter){
			return equals((OutParameter)obj);
		}
		else{
			return false;
		}
	}

	public boolean equals(OutParameter obj){
		if(mySqlType.equals(obj.getSqlType())){
			if(myScale != null){
				return myScale.equals(obj.getScale());
			}
			else{
				if(obj.getScale()==null){

					if(myTypeName != null){
						return
myTypeName.equals(obj.getTypeName());
					}
					else{
						if(obj.getTypeName() ==
null) return true;
						else return false;
					}
				}
				else{
					return false;
				}
			}
		}
		else{
			return false;
		}
	}
}

"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."