/*
 * Copyright 2002 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

/*
 * @(#)callStmtClient17.java	1.9 02/01/12
 */

package com.sun.cts.tests.jdbc.ee.callStmt.callStmt17;

import java.io.*;
import java.util.*;
import java.math.*;

import java.sql.*;
import javax.sql.*;

import com.sun.cts.util.*;
import com.sun.cts.porting.*;
import com.sun.cts.harness.*;

import java.rmi.RemoteException;

import javasoft.sqe.javatest.Status;
import com.sun.cts.tests.jdbc.ee.common.*;


// Merant DataSource class
//import com.merant.sequelink.jdbcx.datasource.*;


/**
 * The callStmtClient17 class tests methods of CallableStatement interface (to check the
 * Support for IN, OUT and INOUT parameters of Stored Procedure) using
 * Sun's J2EE Reference Implementation.
 * @author
 * @version 1.7, 06/16/99
 */

public class callStmtClient17 extends ServiceEETest implements Serializable
{
	private static final String testName = "jdbc.ee.callStmt.callStmt17";

	//Naming specific member variables
	private CTSNamingContextInterface jc = null;

	//Harness requirements

	private transient Connection conn = null;
	private ResultSet rs=null;
	private rsSchema rsSch=null;
	private String drManager=null;
	private Properties sqlp = null;
	private transient DatabaseMetaData dbmd=null;
	private Statement stmt=null;
	private CallableStatement cstmt=null;
	private Properties props=null;

	/* Run test in standalone mode */
	public static void main(String[] args)
	{
		callStmtClient17 theTests = new callStmtClient17();
		Status s=theTests.run(args, System.out, System.err);
		s.exit();
	}

	/*  Test setup: */
	/*
	 *   @class.setup_props: Driver, the Driver name;
	 *			db1, the database name with url;
	 *			user1, the database user name;
	 *			password1, the database password;
	 *			db2, the database name with url;
	 *			user2, the database user name;
	 *			password2, the database password;
	 *			DriverManager, flag for DriverManager;
	 *			ptable, the primary table;
	 *			ftable, the foreign table;
	 *			cofSize, the initial size of the ptable;
	 *			cofTypeSize, the initial size of the ftable;
	 *			binarySize, size of binary data type;
	 *			varbinarySize, size of varbinary data type;
	 *			longvarbinarySize, size of longvarbinary data type;
	 *  @class.testArgs:     -ap ctssql.stmt
	 */
	public void setup(String[] args, Properties p) throws Fault
	{
		try
		{
			try
			{
				drManager = p.getProperty("DriverManager","");
				if (drManager.length() == 0)
					throw new Fault("Invalid DriverManager Name");
				sqlp=p;

				if(drManager.equals("yes"))
				{
					logMsg("Using DriverManager");
					DriverManagerConnection dmCon = new DriverManagerConnection();
					conn = dmCon.getConnection(p);
				}
				else
				{
					logMsg("Using DataSource");
					DataSourceConnection dsCon = new DataSourceConnection();
					conn = dsCon.getConnection(p);
				}
				dbmd = conn.getMetaData();
				stmt = conn.createStatement();
				rsSch = new rsSchema();
			}
			catch(SQLException ex)
			{
				logErr("SQL Exception : " + ex.getMessage());
			}
		}
		catch  ( Exception e )
		{
			logErr("Setup Failed!");
			TestUtil.printStackTrace(e);
		}
	}


	/*
	 * @testName:         testSetObject181
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x, int targetSqlType)
	 *                    method,update the column Min_Val of Bit_Tab with the maximum
	 *                    value of Bit_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the maximum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject181() throws Fault
	{
		Float maxFloatVal;
		Boolean rBooleanVal;
		String  smaxStringVal = null;
		try
		{
			rsSch.createTab("Bit_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Bit_In_Min(?)}");

			//to extract the Minimum Value to be Updated
			smaxStringVal = rsSch.extractVal("Bit_Tab",1,sqlp,conn);
			Boolean maxBooleanVal = new Boolean(smaxStringVal);
			//maxFloatVal = new Float(smaxStringVal);
			//logMsg("Minimum  Value to be updated :" + maxFloatVal);

			//to set the Float
			cstmt.setObject(1,maxBooleanVal,java.sql.Types.BIT);
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Max_Val_Query=sqlp.getProperty("Bit_Query_Min","");
			logMsg(Max_Val_Query);
			rs=stmt.executeQuery(Max_Val_Query);
			rs.next();

			rBooleanVal= (Boolean) rs.getObject(1);
			logMsg("Returned Value after Updation:"+ rBooleanVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxBooleanVal);

			if (rBooleanVal.equals(maxBooleanVal))
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Bit_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject182
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x,int targetSqlType)
	 *                    method,update the column Null_Val of Bit_Tab with the minimum value
	 *                    of Bit_Tab. Call the getObject(int columnno) method to retrieve
	 *                    this value. Extract the minimum value from the ctssql.stmt file.
	 *                    Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject182() throws Fault
	{
		Float minFloatVal;
		Boolean rBooleanVal;
		String  sminStringVal = null;
		try
		{
			rsSch.createTab("Bit_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Bit_In_Null(?)}");

			//to extract the Maximum Value to be Updated
			sminStringVal = rsSch.extractVal("Bit_Tab",2,sqlp,conn);
			Boolean minBooleanVal = new Boolean(sminStringVal);
			//minFloatVal = new Float(sminStringVal);
			//logMsg("Maximum Value to be updated :" + minFloatVal);

			//to set the Value
			cstmt.setObject(1,minBooleanVal,java.sql.Types.BIT);
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Null_Val_Query=sqlp.getProperty("Bit_Query_Null","");
			logMsg(Null_Val_Query);
			rs=stmt.executeQuery(Null_Val_Query);
			rs.next();

			rBooleanVal= (Boolean) rs.getObject(1);
			logMsg("Returned Value after Updation:"+ rBooleanVal);
			logMsg("Returned Value from ctssql.stmt:"+ minBooleanVal);

			if (rBooleanVal.equals(minBooleanVal))
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Bit_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject183
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x, int targetSqlType)
	 *                    method,update the column Min_Val of Char_Tab with the maximum
	 *                    value of Char_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the maximum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject183() throws Fault
	{
		Float maxFloatVal;
		String rStringVal;
		String  smaxStringVal = null;
		try
		{
			rsSch.createTab("Char_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Char_In_Name(?)}");

			//to extract the Minimum Value to be Updated
			smaxStringVal = rsSch.extractVal("Float_Tab",1,sqlp,conn);
			String maxStringVal = new String(smaxStringVal);
			maxFloatVal = new Float(smaxStringVal);
			logMsg("Minimum  Value to be updated :" + maxFloatVal);

			//to set the Float
			cstmt.setObject(1,maxFloatVal,java.sql.Types.CHAR);
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Max_Val_Query=sqlp.getProperty("Char_Query_Name","");
			logMsg(Max_Val_Query);
			rs=stmt.executeQuery(Max_Val_Query);
			rs.next();

			rStringVal= (String) rs.getObject(1);
			logMsg("Returned Value after Updation:"+ rStringVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxStringVal);
			maxStringVal = maxStringVal.trim();
			rStringVal= rStringVal.trim();
			logMsg("Returned Value after Updation:"+ rStringVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxStringVal);

			if (rStringVal.equals(maxStringVal))
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Char_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject184
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x,int targetSqlType)
	 *                    method,update the column Null_Val of Char_Tab with the minimum
	 *                    value of Char_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the minimum value from the ctssql.stmt
	 *                    file. Compare this value  with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject184() throws Fault
	{
		Float minFloatVal;
		String rStringVal;
		String  sminStringVal = null;
		try
		{
			rsSch.createTab("Char_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Char_In_Null(?)}");

			//to extract the Maximum Value to be Updated
			sminStringVal = rsSch.extractVal("Float_Tab",2,sqlp,conn);
			String minStringVal = new String(sminStringVal);
			minFloatVal = new Float(sminStringVal);
			logMsg("Maximum Value to be updated :" + minFloatVal);

			//to set the Value
			cstmt.setObject(1,minFloatVal,java.sql.Types.CHAR);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Null_Val_Query=sqlp.getProperty("Char_Query_Null","");
			logMsg(Null_Val_Query);
			rs=stmt.executeQuery(Null_Val_Query);
			rs.next();

			rStringVal= (String) rs.getObject(1);
			logMsg("Returned Value after Updation:"+ rStringVal);
			minStringVal = minStringVal.trim();
			rStringVal= rStringVal.trim();
			logMsg("Returned Value after Updation:"+ rStringVal);
			logMsg("Returned Value from ctssql.stmt:"+ minStringVal);

			if (rStringVal.equalsIgnoreCase(minStringVal))
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Char_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject185
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x, int targetSqlType)
	 *                    method,update the column Min_Val of Varchar_Tab with the maximum
	 *                    value of Varchar_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the maximum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject185() throws Fault
	{
		Float maxFloatVal;
		String rStringVal;
		String  smaxStringVal = null;
		try
		{
			rsSch.createTab("Varchar_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Varchar_In_Name(?)}");

			//to extract the Minimum Value to be Updated
			smaxStringVal = rsSch.extractVal("Float_Tab",1,sqlp,conn);
			String maxStringVal = new String(smaxStringVal);
			maxFloatVal= new Float(smaxStringVal);
			logMsg("Minimum  Value to be updated :" + maxFloatVal);

			//to set the Float
			cstmt.setObject(1,maxStringVal,java.sql.Types.VARCHAR);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Max_Val_Query=sqlp.getProperty("Varchar_Query_Name","");
			logMsg(Max_Val_Query);
			rs=stmt.executeQuery(Max_Val_Query);
			rs.next();

			rStringVal= (String) rs.getObject(1);
			logMsg("Returned Value after Updation:"+ rStringVal);
			maxStringVal = maxStringVal.trim();
			rStringVal= rStringVal.trim();
			logMsg("Returned Value after Updation:"+ rStringVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxStringVal);

			if (rStringVal.equals(maxStringVal))
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Varchar_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject186
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x,int targetSqlType)
	 *                    method,update the column Null_Val of Varchar_Tab with the minimum
	 *                    value of Varchar_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the minimum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject186() throws Fault
	{
		Float minFloatVal;
		String rStringVal;
		String  sminStringVal = null;
		try
		{
			rsSch.createTab("Varchar_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Varchar_In_Null(?)}");

			//to extract the Maximum Value to be Updated
			sminStringVal = rsSch.extractVal("Float_Tab",2,sqlp,conn);
			String minStringVal = new String(sminStringVal);
			minFloatVal = new Float(sminStringVal);
			logMsg("Maximum Value to be updated :" + minFloatVal);

			//to set the Value
			cstmt.setObject(1,minFloatVal,java.sql.Types.VARCHAR);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Null_Val_Query=sqlp.getProperty("Varchar_Query_Null","");
			logMsg(Null_Val_Query);
			rs=stmt.executeQuery(Null_Val_Query);
			rs.next();
			rStringVal= (String) rs.getObject(1);
			logMsg("Returned Value after Updation:"+ rStringVal);
			minStringVal = minStringVal.trim();
			rStringVal= rStringVal.trim();
			logMsg("Returned Value after Updation:"+ rStringVal);
			logMsg("Returned Value from ctssql.stmt:"+ minStringVal);

			if (rStringVal.equalsIgnoreCase(minStringVal))
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Varchar_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject187
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x, int targetSqlType)
	 *                    method,update the column Min_Val of Longvarchar_Tab with the
	 *                    maximum value of Longvarchar_Tab. Call the getObject(int columnno)
	 *                    method to retrieve this value. Extract the maximum value from the
	 *                    ctssql.stmt file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject187() throws Fault
	{
		Float maxFloatVal;
		String rStringVal;
		String  smaxStringVal = null;
		try
		{
			rsSch.createTab("Longvarchar_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Longvarchar_In_Name(?)}");

			//to extract the Minimum Value to be Updated
			smaxStringVal = rsSch.extractVal("Float_Tab",1,sqlp,conn);
			String maxStringVal = new String(smaxStringVal);
			maxFloatVal= new Float(smaxStringVal);
			logMsg("Minimum  Value to be updated :" + maxFloatVal);

			//to set the Float
			cstmt.setObject(1,maxFloatVal,java.sql.Types.LONGVARCHAR);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Max_Val_Query=sqlp.getProperty("Longvarchar_Query_Name","");
			logMsg(Max_Val_Query);
			rs=stmt.executeQuery(Max_Val_Query);
			rs.next();

			rStringVal= (String) rs.getObject(1);
			logMsg("Returned Value after Updation:"+ rStringVal);
			maxStringVal = maxStringVal.trim();
			rStringVal= rStringVal.trim();
			logMsg("Returned Value after Updation:"+ rStringVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxStringVal);

			if (rStringVal.equals(maxStringVal))
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Longvarchar_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject188
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x,int targetSqlType)
	 *                    method,update the column Null_Val of Longvarchar_Tab with the
	 *                    minimum value of Longvarchar_Tab. Call the getObject(int columnno)
	 *                    method to retrieve this value. Extract the minimum value from the
	 *                    ctssql.stmt file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject188() throws Fault
	{
		Float minFloatVal;
		String rStringVal;
		String  sminStringVal = null;
		try
		{
			rsSch.createTab("Longvarcharnull_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Longvarchar_In_Null(?)}");

			//to extract the Maximum Value to be Updated
			sminStringVal = rsSch.extractVal("Float_Tab",2,sqlp,conn);
			String minStringVal = new String(sminStringVal);
			minFloatVal = new Float(sminStringVal);
			logMsg("Maximum Value to be updated :" + minFloatVal);

			//to set the Value
			cstmt.setObject(1,minFloatVal,java.sql.Types.LONGVARCHAR);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Null_Val_Query=sqlp.getProperty("Longvarchar_Query_Null","");
			logMsg(Null_Val_Query);
			rs=stmt.executeQuery(Null_Val_Query);
			rs.next();

			rStringVal= (String) rs.getObject(1);
			logMsg("Returned Value after Updation:"+ rStringVal);
			minStringVal = minStringVal.trim();
			rStringVal= rStringVal.trim();
			logMsg("Returned Value after Updation:"+ rStringVal);
			logMsg("Returned Value from ctssql.stmt:"+ minStringVal);

			if (rStringVal.equals(minStringVal))
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Longvarcharnull_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject189
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x, int targetSqlType)
	 *                    method,update the column Min_Val of Tinyint_Tab with the maximum
	 *                    value of Tinyint_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the maximum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject189() throws Fault
	{
		Double maxDoubleVal;
		Integer rIntegerVal;
		String  smaxStringVal = null;
		try
		{
			rsSch.createTab("Tinyint_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Tinyint_In_Min(?)}");

			//to extract the Minimum Value to be Updated
			smaxStringVal = rsSch.extractVal("Tinyint_Tab",1,sqlp,conn);
			Integer maxIntegerVal = new Integer(smaxStringVal);
			maxDoubleVal = new Double(smaxStringVal);
			logMsg("Minimum Value to be updated :" + maxDoubleVal);

			//to set the Long
			cstmt.setObject(1,maxDoubleVal,java.sql.Types.TINYINT);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Max_Val_Query=sqlp.getProperty("Tinyint_Query_Min","");
			logMsg(Max_Val_Query);
			rs=stmt.executeQuery(Max_Val_Query);
			rs.next();

			Object oIntegerVal= rs.getObject(1);
			rIntegerVal = new Integer(oIntegerVal.toString());
			
			logMsg("Returned Value after Updation:"+ rIntegerVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxIntegerVal);

			if (rIntegerVal.compareTo(maxIntegerVal)==0)
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Tinyint_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject190
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x,int targetSqlType)
	 *                    method,update the column Null_Val of Tinyint_Tab with the minimum
	 *                    value of Tinyint_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the minimum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject190() throws Fault
	{
		Double minDoubleVal;
		Integer rIntegerVal;
		String  sminStringVal = null;
		try
		{
			rsSch.createTab("Tinyint_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Tinyint_In_Null(?)}");

			//to extract the Maximum Value to be Updated
			sminStringVal = rsSch.extractVal("Tinyint_Tab",2,sqlp,conn);
			Integer minIntegerVal = new Integer(sminStringVal);
			minDoubleVal = new Double(sminStringVal);
			logMsg("Maximum Value to be updated :" + minDoubleVal);

			//to set the Value
			cstmt.setObject(1,minDoubleVal,java.sql.Types.TINYINT);

			//execute the procedure
			cstmt.executeUpdate();
			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Null_Val_Query=sqlp.getProperty("Tinyint_Query_Null","");
			logMsg(Null_Val_Query);
			rs=stmt.executeQuery(Null_Val_Query);
			rs.next();

			Object oIntegerVal= rs.getObject(1);
			rIntegerVal = new Integer(oIntegerVal.toString());
			logMsg("Returned Long Value after Updation:"+ rIntegerVal);
			logMsg("Returned Value from ctssql.stmt:"+ minIntegerVal);

			if (rIntegerVal.compareTo(minIntegerVal)==0)
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Tinyint_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject191
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x, int targetSqlType)
	 *                    method,update the column Min_Val of Smallint_Tab with the maximum
	 *                    value of Smallint_Tab. Call the getObject(int columnno) method
	 *                    to retrieve this value. Extract the maximum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject191() throws Fault
	{
		Double maxDoubleVal;
		Integer rIntegerVal;
		String  smaxStringVal = null;
		try
		{
			rsSch.createTab("Smallint_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Smallint_In_Min(?)}");

			//to extract the Minimum Value to be Updated
			smaxStringVal = rsSch.extractVal("Smallint_Tab",1,sqlp,conn);
			Integer maxIntegerVal = new Integer(smaxStringVal);
			maxDoubleVal = new Double(smaxStringVal);
			logMsg("Minimum  Value to be updated :" + maxDoubleVal);

			//to set the Double
			cstmt.setObject(1,maxDoubleVal,java.sql.Types.SMALLINT);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Max_Val_Query=sqlp.getProperty("Smallint_Query_Min","");
			logMsg(Max_Val_Query);
			rs=stmt.executeQuery(Max_Val_Query);
			rs.next();

			Object oIntegerVal= rs.getObject(1);
			rIntegerVal = new Integer(oIntegerVal.toString());
			logMsg("Returned Value after Updation:"+ rIntegerVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxIntegerVal);

			if (rIntegerVal.compareTo(maxIntegerVal)==0)
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Smallint_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject192
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x,int targetSqlType)
	 *                    method,update the column Null_Val of Smallint_Tab with the minimum
	 *                    value of Smallint_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the minimum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject192() throws Fault
	{
		Double minDoubleVal;
		Integer rIntegerVal;
		String  sminStringVal = null;
		try
		{
			rsSch.createTab("Smallint_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Smallint_In_Null(?)}");

			//to extract the Maximum Value to be Updated
			sminStringVal = rsSch.extractVal("Smallint_Tab",2,sqlp,conn);
			Integer minIntegerVal = new Integer(sminStringVal);
			minDoubleVal = new Double(sminStringVal);
			logMsg("Maximum Value to be updated :" + minDoubleVal);

			//to set the Value
			cstmt.setObject(1,minDoubleVal,java.sql.Types.SMALLINT);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Null_Val_Query=sqlp.getProperty("Smallint_Query_Null","");
			logMsg(Null_Val_Query);
			rs=stmt.executeQuery(Null_Val_Query);
			rs.next();

			Object oIntegerVal= rs.getObject(1);
			rIntegerVal = new Integer(oIntegerVal.toString());
			logMsg("Returned Value after Updation:"+ rIntegerVal);
			logMsg("Returned Value from ctssql.stmt:"+ minIntegerVal);

			if (rIntegerVal.compareTo(minIntegerVal)==0)
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Smallint_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject193
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x, int targetSqlType)
	 *                    method,update the column Min_Val of Integer_Tab with the maximum
	 *                    value of Integer_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the maximum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject193() throws Fault
	{
		Double maxDoubleVal;
		Integer rIntegerVal;
		String  smaxStringVal = null;
		try
		{
			rsSch.createTab("Integer_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Integer_In_Min(?)}");

			//to extract the Minimum Value to be Updated
			smaxStringVal = rsSch.extractVal("Integer_Tab",1,sqlp,conn);
			Integer maxIntegerVal = new Integer(smaxStringVal);
			maxDoubleVal = new Double(smaxStringVal);
			logMsg("Minimum  Value to be updated :" + maxDoubleVal);

			//to set the Double
			cstmt.setObject(1,maxDoubleVal,java.sql.Types.INTEGER);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Max_Val_Query=sqlp.getProperty("Integer_Query_Min","");
			logMsg(Max_Val_Query);
			rs=stmt.executeQuery(Max_Val_Query);
			rs.next();

			Object oIntegerVal= rs.getObject(1);
			rIntegerVal = new Integer(oIntegerVal.toString());
			logMsg("Returned Value after Updation:"+ rIntegerVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxIntegerVal);

			if (rIntegerVal.compareTo(maxIntegerVal)==0)
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Integer_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject194
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x,int targetSqlType)
	 *                    method,update the column Null_Val of Integer_Tab with the minimum
	 *                    value of Integer_Tab. Call the getObject(int columnno) method
	 *                    to retrieve this value. Extract the minimum value from the
	 *                    ctssql.stmt file. Compare this value with the value returned by
	 *                    the getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject194() throws Fault
	{
		Double minDoubleVal;
		Integer rIntegerVal;
		String  sminStringVal = null;
		try
		{
			rsSch.createTab("Integer_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Integer_In_Null(?)}");

			//to extract the Maximum Value to be Updated
			sminStringVal = rsSch.extractVal("Integer_Tab",2,sqlp,conn);
			Integer minIntegerVal = new Integer(sminStringVal);
			minDoubleVal = new Double(sminStringVal);
			logMsg("Maximum Value to be updated :" + minDoubleVal);

			//to set the Value
			cstmt.setObject(1,minDoubleVal,java.sql.Types.INTEGER);
			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Null_Val_Query=sqlp.getProperty("Integer_Query_Null","");
			logMsg(Null_Val_Query);
			rs=stmt.executeQuery(Null_Val_Query);
			rs.next();

			Object oIntegerVal= rs.getObject(1);
			rIntegerVal = new Integer(oIntegerVal.toString());
			logMsg("Returned Value after Updation:"+ rIntegerVal);
			logMsg("Returned Value from ctssql.stmt:"+ minIntegerVal);

			if (rIntegerVal.compareTo(minIntegerVal)==0)
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Integer_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject195
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x, int targetSqlType)
	 *                    method,update the column Min_Val of Bigint_Tab with the maximum
	 *                    value of Bigint_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the maximum value from the
	 *                    ctssql.stmt file. Compare this value with the value returned by
	 *                    the getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject195() throws Fault
	{
		Double maxDoubleVal;
		Long rLongVal;
		String  smaxStringVal = null;
		try
		{
			rsSch.createTab("Bigint_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Bigint_In_Min(?)}");

			//to extract the Minimum Value to be Updated
			smaxStringVal = rsSch.extractVal("Bigint_Tab",1,sqlp,conn);
			Long maxLongVal = new Long(smaxStringVal);
			maxDoubleVal = new Double(smaxStringVal);
			logMsg("Minimum  Value to be updated :" + maxDoubleVal);

			//to set the Double
			cstmt.setObject(1,maxDoubleVal,java.sql.Types.BIGINT);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Max_Val_Query=sqlp.getProperty("Bigint_Query_Min","");
			logMsg(Max_Val_Query);
			rs=stmt.executeQuery(Max_Val_Query);
			rs.next();

			Object oLongVal= rs.getObject(1);
			rLongVal = new Long(oLongVal.toString());
			logMsg("Returned Value after Updation:"+ rLongVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxLongVal);

			if (rLongVal.compareTo(maxLongVal)==0)
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Bigint_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject196
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x,int targetSqlType)
	 *                    method,update the column Null_Val of Bigint_Tab with the minimum
	 *                    value of Bigint_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the minimum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject196() throws Fault
	{
		Double minDoubleVal;
		Long rLongVal;
		String  sminStringVal = null;
		try
		{
			rsSch.createTab("Bigint_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Bigint_In_Null(?)}");

			//to extract the Maximum Value to be Updated
			sminStringVal = rsSch.extractVal("Bigint_Tab",2,sqlp,conn);
			Long minLongVal = new Long(sminStringVal);
			minDoubleVal = new Double(sminStringVal);
			logMsg("Maximum Value to be updated :" + minDoubleVal);

			//to set the Value
			cstmt.setObject(1,minDoubleVal,java.sql.Types.BIGINT);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Null_Val_Query=sqlp.getProperty("Bigint_Query_Null","");
			logMsg(Null_Val_Query);
			rs=stmt.executeQuery(Null_Val_Query);
			rs.next();

			Object oLongVal= rs.getObject(1);
			rLongVal = new Long(oLongVal.toString());
			logMsg("Returned Value after Updation:"+ rLongVal);
			logMsg("Returned Value from ctssql.stmt:"+ minLongVal);

			if (rLongVal.compareTo(minLongVal)==0)
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Bigint_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject197
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x, int targetSqlType)
	 *                    method,update the column Min_Val of Real_Tab with the maximum value
	 *                    of Real_Tab. Call the getObject(int columnno) method to retrieve
	 *                    this value. Extract the maximum value from the ctssql.stmt file.
	 *                    Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject197() throws Fault
	{
		Double maxDoubleVal;
		Float rFloatVal;
		String  smaxStringVal = null;
		try
		{
			rsSch.createTab("Real_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Real_In_Min(?)}");

			//to extract the Minimum Value to be Updated
			smaxStringVal = rsSch.extractVal("Real_Tab",1,sqlp,conn);
			Float maxFloatVal = new Float(smaxStringVal);
			maxDoubleVal = new Double(smaxStringVal);
			logMsg("Minimum  Value to be updated :" + maxDoubleVal);

			//to set the Double
			cstmt.setObject(1,maxDoubleVal,java.sql.Types.REAL);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Max_Val_Query=sqlp.getProperty("Real_Query_Min","");
			logMsg(Max_Val_Query);
			rs=stmt.executeQuery(Max_Val_Query);
			rs.next();

			Object oFloatVal= rs.getObject(1);
			rFloatVal = new Float(oFloatVal.toString());
			logMsg("Returned Value after Updation:"+ rFloatVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxFloatVal);

			if (rFloatVal.compareTo(maxFloatVal)==0)
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Real_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject198
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x,int targetSqlType)
	 *                    method,update the column Null_Val of Real_Tab with the minimum
	 *                    value of Real_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the minimum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject198() throws Fault
	{
		Double minDoubleVal;
		Float rFloatVal;
		String  sminStringVal = null;
		try
		{
			rsSch.createTab("Real_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Real_In_Null(?)}");

			//to extract the Maximum Value to be Updated
			sminStringVal = rsSch.extractVal("Real_Tab",2,sqlp,conn);
			Float minFloatVal = new Float(sminStringVal);
			minDoubleVal = new Double(sminStringVal);
			logMsg("Maximum Value to be updated :" + minDoubleVal);

			//to set the Value
			cstmt.setObject(1,minDoubleVal,java.sql.Types.REAL);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Null_Val_Query=sqlp.getProperty("Real_Query_Null","");
			logMsg(Null_Val_Query);
			rs=stmt.executeQuery(Null_Val_Query);
			rs.next();

			Object oFloatVal= rs.getObject(1);
			rFloatVal = new Float(oFloatVal.toString());
			logMsg("Returned Value after Updation:"+ rFloatVal);
			logMsg("Returned Value from ctssql.stmt:"+ minFloatVal);

			if (rFloatVal.compareTo(minFloatVal)==0)
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Real_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject199
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x, int targetSqlType)
	 *                    method,update the column Min_Val of Float_Tab with the maximum
	 *                    value of Float_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the maximum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject199() throws Fault
	{
		Double maxDoubleVal;
		Double rDoubleVal;
		String  smaxStringVal = null;
		try
		{
			rsSch.createTab("Float_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Float_In_Min(?)}");

			//to extract the Minimum Value to be Updated
			smaxStringVal = rsSch.extractVal("Float_Tab",1,sqlp,conn);
			maxDoubleVal = new Double(smaxStringVal);
			logMsg("Minimum  Value to be updated :" + maxDoubleVal);

			//to set the Double
			cstmt.setObject(1,maxDoubleVal,java.sql.Types.FLOAT);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Max_Val_Query=sqlp.getProperty("Float_Query_Min","");
			logMsg(Max_Val_Query);
			rs=stmt.executeQuery(Max_Val_Query);
			rs.next();

			rDoubleVal= (Double) rs.getObject(1);
			logMsg("Returned Value after Updation:"+ rDoubleVal);
			logMsg("Returned Value from ctssql.stmt:"+ maxDoubleVal);

			if (rDoubleVal.equals(maxDoubleVal))
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Float_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/*
	 * @testName:         testSetObject200
	 * @assertion:        A CallableStatement object provides a way to call stored procedures
	 *                    in a standard way for all RDBMSs.  It can take variable number of
	 *                    parameters used for input (IN parameters), output (OUT parameters)
	 *                    or both (INOUT parameters).  (See section 9.1 of JDBC 2.0 API
	 *                    Reference & Tutorial, Second Edition)
	 *
	 *                    The drivers must provide full support for CallableStatement methods
	 *                    that apply to SQL92 types.  All parameter types (IN, OUT, INOUT)
	 *                    must be supported (See section 6.2.2.3 of Java2 Platform Enterprise
	 *                    Edition (J2EE) specification v 1.2)
	 *
	 *                    The setObject(int parameterIndex, Object x,int targetsqlType) method
	 *                    sets the value of the designated parameter using the given object.
	 *                    The second parameter must be of type Object; therefore, the
	 *                    java.lang equivalent objects should be used for built-in types.
	 *                    The JDBC specification specifies a standard mapping from Java
	 *                    Object types to SQL types. The given argument will be converted
	 *                    to the corresponding SQL type before being sent to the database.
	 *                    (See JDK 1.2.2 API specification)
	 *
	 * @test_Strategy:    Get a CallableStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x,int targetSqlType)
	 *                    method,update the column Null_Val of Double_Tab with the minimum
	 *                    value of Double_Tab. Call the getObject(int columnno) method to
	 *                    retrieve this value. Extract the minimum value from the ctssql.stmt
	 *                    file. Compare this value with the value returned by the
	 *                    getObject(int columnno) method. Both the values should be equal.
	 */
	public void testSetObject200() throws Fault
	{
		Double minDoubleVal;
		Double rDoubleVal;
		String  sminStringVal = null;
		try
		{
			rsSch.createTab("Float_Tab",sqlp,conn);

			// get the CallableStatement object
			cstmt = conn.prepareCall("{call Float_In_Null(?)}");

			//to extract the Maximum Value to be Updated
			sminStringVal = rsSch.extractVal("Float_Tab",2,sqlp,conn);
			minDoubleVal = new Double(sminStringVal);
			logMsg("Maximum Value to be updated :" + minDoubleVal);

			//to set the Value
			cstmt.setObject(1,minDoubleVal,java.sql.Types.FLOAT);

			//execute the procedure
			cstmt.executeUpdate();

			//to query from the database to check the call of cstmt.executeUpdate
			//to get the query string
			String Null_Val_Query=sqlp.getProperty("Float_Query_Null","");
			logMsg(Null_Val_Query);
			rs=stmt.executeQuery(Null_Val_Query);
			rs.next();

			rDoubleVal= (Double) rs.getObject(1);
			logMsg("Returned Value after Updation:"+ rDoubleVal);
			logMsg("Returned Value from ctssql.stmt:"+ minDoubleVal);

			if (rDoubleVal.equals(minDoubleVal))
			{
				logMsg("setObject Method sets the designated parameter value ");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter value ");
				throw new Fault("Call to setObject Method is Failed!");
			}
		}
		catch(SQLException sqle)
		{
			logErr("SQL Exception " + sqle.getMessage());
			throw new Fault("Call to setObject is Failed!");
		}
		catch ( Exception e )
		{
			logErr("Unexpected Exception " + e.getMessage());
			throw new Fault("Call to setObject Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					rs.close();
					rs=null;
				}
				if(cstmt != null)
				{
					cstmt.close();
					cstmt=null;
				}
				rsSch.dropTab("Float_Tab",conn);
			}
			catch(Exception e)
			{

			}
		}
	}


	/* cleanup */
	public void  cleanup() throws Fault
	{
		try
		{
			if(stmt != null)
			{
				stmt.close();
				stmt=null;
			}
			// Close the database
			rsSch.dbUnConnect(conn);
			logMsg("Cleanup ok;");
		}
		catch (Exception e)
		{
			logErr("An error occurred while closing the database connection");
		}
	}
}