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

/*
 * @(#)prepStmtClient9.java	1.8 02/01/12
 */

package com.sun.cts.tests.jdbc.ee.prepStmt.prepStmt9;

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 prepStmtClient9 class tests methods of PreparedStatement interface using 
 * Sun's J2EE Reference Implementation.
 * @author 
 * @version 1.8, 24/11/00
 */


public class prepStmtClient9 extends ServiceEETest implements Serializable
{
	private static final String testName = "jdbc.ee.prepStmt.prepStmt9";

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

	//Harness requirements 

	private transient Connection conn = null;
	private ResultSet rs = null;
	private Statement stmt = null;
	private transient DatabaseMetaData dbmd = null;
	private DataSource ds1 = null;
	private dbSchema dbSch = null;
	private rsSchema rsSch = null;
	private csSchema csSch = null;
	private String drManager = null;
	private Properties sqlp = null;
	private Properties props = null;
	private PreparedStatement pstmt = null;

	/* Run test in standalone mode */
	public static void main(String[] args)
	{
		prepStmtClient9 theTests = new prepStmtClient9();
		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 = new Properties();
				String sqlStmt = p.getProperty("rsQuery","");
				InputStream istr = new FileInputStream(sqlStmt);
				sqlp.load(istr);*/
				sqlp = p;
				props = 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);
				}
				stmt = conn.createStatement();
				dbmd = conn.getMetaData();
				rsSch = new rsSchema();
				csSch = new csSchema();
			}
			catch(SQLException ex)
			{
				logErr("SQL Exception: : " + ex.getMessage());
			}
		}
		catch(Exception e )
		{
			logErr("Setup Failed!");
			TestUtil.printStackTrace(e);
		}
	}



	/*
	 * @testName:         testSetObject103
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Decimal_Tab with the minimum (false) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the minimum (false) 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 testSetObject103() throws Fault 
	{
		Boolean oMinDecimalVal = null;
		BigDecimal rDecimalVal = null;
		String sminDecimalVal = null;
		BigDecimal minDecimalVal = null;
		boolean booleanVal;

		try
		{

			// to create the Decimal Table
			rsSch.createTab("Decimal_Tab",sqlp,conn);

			// to update Minimum value column with minimum value of Double
			String sPrepStmt = sqlp.getProperty("Decimal_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Minimum Value of Boolean to be Updated in Decimal Table
			sminDecimalVal = rsSch.extractVal("Bit_Tab",2,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMinDecimalVal = new Boolean(sminDecimalVal);
				if(sminDecimalVal.equalsIgnoreCase("true"))
				{
					sminDecimalVal = "1";
				}
				else
				{
					sminDecimalVal = "0";
				}
			}
			else
			{
				booleanVal= (sminDecimalVal.trim().equals("1"))? true : false;
				oMinDecimalVal = new Boolean(booleanVal);
			}

			minDecimalVal = new BigDecimal(sminDecimalVal);
			logMsg("Minimum Double Value to be updated in Decimal Table: " + minDecimalVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMinDecimalVal,java.sql.Types.DECIMAL,2);
			pstmt.executeUpdate();

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

			rDecimalVal = (BigDecimal) rs.getObject(1);
			logMsg("Returned Decimal Value after Updation: " + rDecimalVal);
			logMsg("Value returned from ctssql.stmt: " + minDecimalVal);

			if(rDecimalVal.compareTo(minDecimalVal) == 0)
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Decimal_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject104
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Numeric_Tab with the maximum (true) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the maximum (true) 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 testSetObject104() throws Fault
	{
		Boolean oMaxNumericVal = null;
		BigDecimal rNumericVal = null;
		String smaxNumericVal = null;
		BigDecimal maxNumericVal = null;
		boolean booleanVal;

		try
		{

			// to create the Numeric Table
			rsSch.createTab("Numeric_Tab",sqlp,conn);

			// to update Null value column with maximum value of Double
			String sPrepStmt = sqlp.getProperty("Numeric_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Maximum Value of Boolean to be Updated in Numeric Table
			smaxNumericVal = rsSch.extractVal("Bit_Tab",1,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMaxNumericVal = new Boolean(smaxNumericVal);
				if(smaxNumericVal.equalsIgnoreCase("true"))
				{
					smaxNumericVal = "1";
				}
				else
				{
					smaxNumericVal = "0";
				}
			}
			else
			{
				booleanVal= (smaxNumericVal.trim().equals("1"))? true : false;
				oMaxNumericVal = new Boolean(booleanVal);
			}

			maxNumericVal = new BigDecimal(smaxNumericVal);
			logMsg("Maximum Double Value to be updated in Numeric Table: " + maxNumericVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMaxNumericVal,java.sql.Types.NUMERIC,2);
			pstmt.executeUpdate();

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

			rNumericVal = (BigDecimal) rs.getObject(1);
			logMsg("Returned Numeric Value after Updation: " + rNumericVal);
			logMsg("Value returned from ctssql.stmt: " + maxNumericVal);

			if(rNumericVal.compareTo(maxNumericVal) == 0)
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Numeric_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject105
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Min_Val of Numeric_Tab with the minimum (false) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the minimum (false) 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 testSetObject105() throws Fault
	{
		Boolean oMinNumericVal = null;
		BigDecimal rNumericVal = null;
		String sminNumericVal = null;
		BigDecimal minNumericVal = null;
		boolean booleanVal;

		try
		{

			// to create the Numeric Table
			rsSch.createTab("Numeric_Tab",sqlp,conn);

			// to update Minimum value column with minimum value of Double
			String sPrepStmt = sqlp.getProperty("Numeric_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Minimum Value of Boolean to be Updated in Numeric Table
			sminNumericVal = rsSch.extractVal("Bit_Tab",2,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMinNumericVal = new Boolean(sminNumericVal);
				if(sminNumericVal.equalsIgnoreCase("true"))
				{
					sminNumericVal = "1";
				}
				else
				{
					sminNumericVal = "0";
				}
			}
			else
			{
				booleanVal= (sminNumericVal.trim().equals("1"))? true : false;
				oMinNumericVal = new Boolean(booleanVal);
			}

			minNumericVal = new BigDecimal(sminNumericVal);
			logMsg("Minimum Double Value to be updated in Numeric Table: " + minNumericVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMinNumericVal,java.sql.Types.NUMERIC,2);
			pstmt.executeUpdate();

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

			rNumericVal = (BigDecimal) rs.getObject(1);
			logMsg("Returned Numeric Value after Updation: " + rNumericVal);
			logMsg("Value returned from ctssql.stmt: " + minNumericVal);

			if(rNumericVal.compareTo(minNumericVal) == 0)
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Numeric_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject106
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Bit_Tab with the maximum (true) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the maximum (true) 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 testSetObject106() throws Fault
	{
		Boolean oMaxBooleanVal = null;
		String smaxBooleanVal = null;
		String rStringVal=null;
		Boolean rBooleanVal = null;
		boolean booleanVal;

		try
		{

			// to create the Bit Table
			rsSch.createTab("Bit_Tab",sqlp,conn);

			// to update Null value column of Bit table 
			String sPrepStmt = sqlp.getProperty("Bit_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Maximum Value of Bit to be Updated in Bit Table
			smaxBooleanVal = rsSch.extractVal("Bit_Tab",1,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMaxBooleanVal = new Boolean(smaxBooleanVal);
			}
			else
			{
				booleanVal= (smaxBooleanVal.trim().equals("1"))? true : false;
				oMaxBooleanVal = new Boolean(booleanVal);
			}

			logMsg("Maximum Bit Value to be updated :" + oMaxBooleanVal);
			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMaxBooleanVal,java.sql.Types.BIT);
			pstmt.executeUpdate();

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

			Object orBooleanVal =  rs.getObject(1);
			//rBooleanVal = new Boolean(orBooleanVal.toString());
			
			rStringVal = orBooleanVal.toString().trim();
						
			logMsg("Returned String Value after Updation: " + rStringVal);
			logMsg("Value returned from ctssql.stmt: " + oMaxBooleanVal);

			if (rStringVal.equals(oMaxBooleanVal.toString()) || rStringVal.equals(smaxBooleanVal.trim()))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Bit_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject107
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Bit_Tab with the minimum (false) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the minimum (false) 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 testSetObject107() throws Fault
	{
		Boolean oMinBooleanVal = null;
		String sminBooleanVal = null;
		String rStringVal = null;
		Boolean rBooleanVal = null;
		boolean booleanVal;

		try
		{

			// to create the Bit Table
			rsSch.createTab("Bit_Tab",sqlp,conn);

			// to update Null value column with minimum value of Bit
			String sPrepStmt = sqlp.getProperty("Bit_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Minimum Value of Bit to be Updated 
			sminBooleanVal = rsSch.extractVal("Bit_Tab",2,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMinBooleanVal = new Boolean(sminBooleanVal);
			}
			else
			{
				booleanVal= (sminBooleanVal.trim().equals("1"))? true : false;
				oMinBooleanVal = new Boolean(booleanVal);
			}

			logMsg("Minimum Bit Value to be updated :" + oMinBooleanVal);
			//get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMinBooleanVal,java.sql.Types.BIT);
			pstmt.executeUpdate();

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

			Object orBooleanVal = rs.getObject(1);
			//rBooleanVal = new Boolean(orBooleanVal.toString());
			
			rStringVal =  orBooleanVal.toString().trim();
						
			logMsg("Returned String Value after Updation: " + rStringVal);
			logMsg("Value returned from ctssql.stmt: " + oMinBooleanVal);

			if (rStringVal.equals(oMinBooleanVal.toString()) || rStringVal.equals(sminBooleanVal.trim()))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Bit_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject108
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Char_Tab with the maximum (true) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the maximum (true) 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 testSetObject108() throws Fault
	{
		Boolean oMaxBooleanVal = null;
		String smaxBooleanVal = null;
		String rStringVal = null;
		Boolean rBooleanVal = null;
		boolean booleanVal;

		try
		{
			// to create the Char Table
			rsSch.createTab("Char_Tab",sqlp,conn);

			// to update Null value column of Char table with maximum value of Double
			String sPrepStmt = sqlp.getProperty("Char_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Maximum Value of Boolean to be Updated in Char Table
			smaxBooleanVal = rsSch.extractVal("Bit_Tab",1,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMaxBooleanVal = new Boolean(smaxBooleanVal);
			}
			else
			{
				booleanVal= (smaxBooleanVal.trim().equals("1"))? true : false;
				oMaxBooleanVal = new Boolean(booleanVal);
			}

			logMsg("Maximum Boolean Value to be updated in Char Table: " + oMaxBooleanVal);
			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMaxBooleanVal,java.sql.Types.CHAR);
			pstmt.executeUpdate();

			//to query from the database to check the call of pstmt.executeUpdate
			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);
			rStringVal = rStringVal.trim();
			//rBooleanVal = new Boolean(rStringVal);
			logMsg("Returned String Value after Updation: " + rStringVal);
			logMsg("Value returned from ctssql.stmt: " + oMaxBooleanVal);

			//if(rBooleanVal.equals(oMaxBooleanVal))
			
			// Tests will pass for three possibilities.
			// 1. A driver supports boolean and saves boolean as "true" in char_tab
			// 2. A driver doesn't support boolean , saves boolean as "1" in char_tab
			// 3. A driver doesn't support boolean , saves boolean as "true" in char_tab
			
			if (rStringVal.equals(oMaxBooleanVal.toString()) || rStringVal.equals(smaxBooleanVal.trim()))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Char_Tab",conn);
			}
			catch(Exception e){ }
		}
	}




	/*
	 * @testName:         testSetObject109
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Char_Tab with the minimum (false) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the minimum (false) 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 testSetObject109() throws Fault
	{
		Boolean oMinBooleanVal = null;
		String sminBooleanVal = null;
		String rStringVal = null;
		Boolean rBooleanVal = null;
		boolean booleanVal;

		try
		{

			// to create the Char Table
			rsSch.createTab("Char_Tab",sqlp,conn);

			// to update Minimum value column with minimum value of Float
			String sPrepStmt = sqlp.getProperty("Char_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Minimum Value of Boolean to be Updated in Char Table
			sminBooleanVal = rsSch.extractVal("Bit_Tab",2,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMinBooleanVal = new Boolean(sminBooleanVal);
			}
			else
			{
				booleanVal= (sminBooleanVal.trim().equals("1"))? true : false;
				oMinBooleanVal = new Boolean(booleanVal);
			}

			logMsg("Minimum Boolean Value to be updated in Char Table: " + oMinBooleanVal);
			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMinBooleanVal,java.sql.Types.CHAR);
			pstmt.executeUpdate();

			//to query from the database to check the call of pstmt.executeUpdate
			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);
			rStringVal = rStringVal.trim();
			//rBooleanVal = new Boolean(rStringVal);
			logMsg("Returned String Value after Updation: " + rStringVal);
			logMsg("Value returned from ctssql.stmt: " + oMinBooleanVal);

			//if(rBooleanVal.equals(oMinBooleanVal))
			
			// Tests will pass for three possibilities.
			// 1. A driver supports boolean and saves boolean as "true" in char_tab
			// 2. A driver doesn't support boolean , saves boolean as "1" in char_tab
			// 3. A driver doesn't support boolean , saves boolean as "true" in char_tab
			
			if (rStringVal.equals(oMinBooleanVal.toString()) || rStringVal.equals(sminBooleanVal.trim()))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Char_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject110
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Varchar_Tab with the maximum (true) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the maximum (true) 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 testSetObject110() throws Fault
	{
		Boolean oMaxBooleanVal = null;
		String smaxBooleanVal = null;
		String rStringVal = null;
		Boolean rBooleanVal = null;
		boolean booleanVal;

		try
		{

			// to create the Varchar Table
			rsSch.createTab("Varchar_Tab",sqlp,conn);

			// to update Null value column of Varchar table 
			String sPrepStmt = sqlp.getProperty("Varchar_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Maximum Value of Boolean to be Updated in Varchar Table
			smaxBooleanVal = rsSch.extractVal("Bit_Tab",1,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMaxBooleanVal = new Boolean(smaxBooleanVal);
			}
			else
			{
				booleanVal = (smaxBooleanVal.trim().equals("1"))? true : false;
				oMaxBooleanVal = new Boolean(booleanVal);
			}

			logMsg("Maximum Boolean Value to be updated in Varchar Table: " + oMaxBooleanVal);
			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMaxBooleanVal,java.sql.Types.VARCHAR);
			pstmt.executeUpdate();

			//to query from the database to check the call of pstmt.executeUpdate
			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);
			rStringVal = rStringVal.trim();
			//rBooleanVal = new Boolean(rStringVal);
			logMsg("Returned String Value after Updation: " + rStringVal);
			logMsg("Value returned from ctssql.stmt: " + oMaxBooleanVal);

			//if(rBooleanVal.equals(oMaxBooleanVal))
			
			// Tests will pass for three possibilities.
			// 1. A driver supports boolean and saves boolean as "true" in char_tab
			// 2. A driver doesn't support boolean , saves boolean as "1" in char_tab
			// 3. A driver doesn't support boolean , saves boolean as "true" in char_tab
			
			if (rStringVal.equals(oMaxBooleanVal.toString()) || rStringVal.equals(smaxBooleanVal.trim()))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Varchar_Tab",conn);
			}
			catch(Exception e){ }
		}
	}




	/*
	 * @testName:         testSetObject111
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Varchar_Tab with the minimum (false) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the minimum (false) 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 testSetObject111() throws Fault
	{
		Boolean oMinBooleanVal = null;
		String sminBooleanVal = null;
		String rStringVal = null;
		Boolean rBooleanVal = null;
		boolean booleanVal;

		try
		{

			// to create the Varchar Table
			rsSch.createTab("Varchar_Tab",sqlp,conn);

			// to update Null value column with Minimum value of Float
			String sPrepStmt = sqlp.getProperty("Varchar_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Minimum Value of Boolean to be Updated in Varchar Table
			sminBooleanVal = rsSch.extractVal("Bit_Tab",2,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMinBooleanVal = new Boolean(sminBooleanVal);
			}
			else
			{
				booleanVal = (sminBooleanVal.trim().equals("1"))? true : false;
				oMinBooleanVal = new Boolean(booleanVal);
			}

			logMsg("Minimum Boolean Value to be updated in Varchar Table: " + oMinBooleanVal);
			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMinBooleanVal,java.sql.Types.VARCHAR);
			pstmt.executeUpdate();

			//to query from the database to check the call of pstmt.executeUpdate
			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);
			rStringVal = rStringVal.trim();
			//rBooleanVal = new Boolean(rStringVal);
			logMsg("Returned String Value after Updation: " + rStringVal);
			logMsg("Value returned from ctssql.stmt: " + oMinBooleanVal);

			//if(rBooleanVal.equals(oMinBooleanVal))
			
			// Tests will pass for three possibilities.
			// 1. A driver supports boolean and saves boolean as "true" in char_tab
			// 2. A driver doesn't support boolean , saves boolean as "1" in char_tab
			// 3. A driver doesn't support boolean , saves boolean as "true" in char_tab
			
			if (rStringVal.equals(oMinBooleanVal.toString()) || rStringVal.equals(sminBooleanVal.trim()))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Varchar_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject112
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Longvarchar_Tab with the maximum (true) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the maximum (true) 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 testSetObject112() throws Fault
	{
		Boolean oMaxBooleanVal = null;
		String smaxBooleanVal = null;
		String rStringVal = null;
		Boolean rBooleanVal = null;
		boolean booleanVal;

		try
		{

			// to create the Longvarchar Table
			rsSch.createTab("Longvarcharnull_Tab",sqlp,conn);

			// to update Null value column of Longvarchar table 
			String sPrepStmt = sqlp.getProperty("Longvarchar_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Maximum Value of Boolean to be Updated in Longvarchar Table
			smaxBooleanVal = rsSch.extractVal("Bit_Tab",1,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMaxBooleanVal = new Boolean(smaxBooleanVal);
			}
			else
			{
				booleanVal= (smaxBooleanVal.trim().equals("1"))? true : false;
				oMaxBooleanVal = new Boolean(booleanVal);
			}

			logMsg("Maximum Boolean Value to be updated in Longvarchar Table: " + oMaxBooleanVal);
			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMaxBooleanVal,java.sql.Types.LONGVARCHAR);
			pstmt.executeUpdate();

			//to query from the database to check the call of pstmt.executeUpdate
			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);
			rStringVal = rStringVal.trim();
			//rBooleanVal = new Boolean(rStringVal);
			logMsg("Returned String Value after Updation: " + rStringVal);
			logMsg("Value returned from ctssql.stmt: " + oMaxBooleanVal);

			//if(rBooleanVal.equals(oMaxBooleanVal))
			
			// Tests will pass for three possibilities.
			// 1. A driver supports boolean and saves boolean as "true" in char_tab
			// 2. A driver doesn't support boolean , saves boolean as "1" in char_tab
			// 3. A driver doesn't support boolean , saves boolean as "true" in char_tab
			
			if (rStringVal.equals(oMaxBooleanVal.toString()) || rStringVal.equals(smaxBooleanVal.trim()))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Longvarchar_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject113
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Float_Tab with the minimum (false) value of 
	 *                    Bit_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the minimum (false) 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 testSetObject113() throws Fault
	{
		Boolean oMinBooleanVal = null;
		String sminBooleanVal = null;
		String rStringVal = null;
		Boolean rBooleanVal = null;
		boolean booleanVal;

		try
		{

			// to create the Longvarchar Table
			rsSch.createTab("Longvarcharnull_Tab",sqlp,conn);

			// to update Null value column with Minimum value of Float
			String sPrepStmt = sqlp.getProperty("Longvarchar_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Minimum Value of Boolean to be Updated in Longvarchar Table
			sminBooleanVal = rsSch.extractVal("Bit_Tab",2,sqlp,conn);

			String testType = new String("BOOLEAN");
			if(csSch.supportsType(testType,conn))
			{
				logMsg("database supports Boolean datatype.");
				oMinBooleanVal = new Boolean(sminBooleanVal);
			}
			else
			{
				booleanVal= (sminBooleanVal.trim().equals("1"))? true : false;
				oMinBooleanVal = new Boolean(booleanVal);
			}

			logMsg("Minimum Boolean Value to be updated in Longvarchar Table: " + oMinBooleanVal);
			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,oMinBooleanVal,java.sql.Types.LONGVARCHAR);
			pstmt.executeUpdate();

			//to query from the database to check the call of pstmt.executeUpdate
			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);
			rStringVal = rStringVal.trim();
			//rBooleanVal = new Boolean(rStringVal);
			logMsg("Returned String Value after Updation: " + rStringVal);
			logMsg("Value returned from ctssql.stmt: " + oMinBooleanVal);

			//if(rBooleanVal.equals(oMinBooleanVal))
			
			// Tests will pass for three possibilities.
			// 1. A driver supports boolean and saves boolean as "true" in char_tab
			// 2. A driver doesn't support boolean , saves boolean as "1" in char_tab
			// 3. A driver doesn't support boolean , saves boolean as "true" in char_tab
			
			if (rStringVal.equals(oMinBooleanVal.toString()) || rStringVal.equals(sminBooleanVal.trim()))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Longvarchar_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject114
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Min_Val of Tinyint_Tab with the maximum (true) value of 
	 *                    Tinyint_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the maximum (true) 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 testSetObject114() throws Fault
	{
		Integer maxIntegerVal = null;
		Integer rTinyintVal = null;
		String smaxStringVal = null;

		try
		{

			// to create the Tinyint Table
			rsSch.createTab("Tinyint_Tab",sqlp,conn);

			// to update Minimum value column with maximum 
			String sPrepStmt = sqlp.getProperty("Tinyint_Tab_Min_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Maximum Value of Tinyint to be Updated 
			smaxStringVal = rsSch.extractVal("Tinyint_Tab",1,sqlp,conn);

			maxIntegerVal = new Integer(smaxStringVal);
			logMsg("Maximum Tinyint Value: " + maxIntegerVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,maxIntegerVal,java.sql.Types.TINYINT);
			pstmt.executeUpdate();

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

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

			if(rTinyintVal.equals(maxIntegerVal))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Tinyint_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject115
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Tinyint_Tab with the minimum (false) value of 
	 *                    Tinyint_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the minimum (false) 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 testSetObject115() throws Fault
	{
		Integer minIntegerVal = null;
		Integer rTinyintVal = null;
		String sminStringVal = null;

		try
		{
			// to create the String Table
			rsSch.createTab("Tinyint_Tab",sqlp,conn);

			// to update Null value column with Minimum value 
			String sPrepStmt = sqlp.getProperty("Tinyint_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Minimum Value of Tinyint to be Updated 
		sminStringVal = rsSch.extractVal("Tinyint_Tab",2,sqlp,conn);

			minIntegerVal = new Integer(sminStringVal);
			logMsg("Minimum Tinyint Value: " + minIntegerVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,minIntegerVal,java.sql.Types.TINYINT);
			pstmt.executeUpdate();

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

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

			if(rTinyintVal.equals(minIntegerVal))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}
		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Tinyint_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject116
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *                    
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *                    
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *                    
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Min_Val of Smallint_Tab with the maximum (true) value of 
	 *                    Smallint_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the maximum (true) 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 testSetObject116() throws Fault
	{
		Integer maxIntegerVal = null;
		Integer rSmallintVal = null;
		String smaxStringVal = null;

		try
		{
			// to create the Smallint Table
			rsSch.createTab("Smallint_Tab",sqlp,conn);

			// to update Minimum value column with maximum 
			String sPrepStmt = sqlp.getProperty("Smallint_Tab_Min_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Maximum Value of Smallint to be Updated 
			smaxStringVal = rsSch.extractVal("Smallint_Tab",1,sqlp,conn);

			maxIntegerVal = new Integer(smaxStringVal);
			logMsg("Maximum Smallint Value: " + maxIntegerVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,maxIntegerVal,java.sql.Types.SMALLINT);
			pstmt.executeUpdate();

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

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

			if(rSmallintVal.equals(maxIntegerVal))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Smallint_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject117
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Smallint_Tab with the minimum (false) value of 
	 *                    Smallint_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the minimum (false) 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 testSetObject117() throws Fault
	{
		Integer minIntegerVal = null;
		Integer rSmallintVal = null;
		String sminStringVal = null;

		try
		{

			// to create the Smallint Table
			rsSch.createTab("Smallint_Tab",sqlp,conn);

			// to update Null value column with Minimum value 
			String sPrepStmt = sqlp.getProperty("Smallint_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Minimum Value of Smallint to be Updated 
			sminStringVal = rsSch.extractVal("Smallint_Tab",2,sqlp,conn);

			minIntegerVal = new Integer(sminStringVal);
			logMsg("Minimum Smallint Value: " + minIntegerVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,minIntegerVal,java.sql.Types.SMALLINT);
			pstmt.executeUpdate();

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

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

			if(rSmallintVal.equals(minIntegerVal))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Smallint_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject118
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Min_Val of Integer_Tab with the maximum (true) value of 
	 *                    Integer_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the maximum (true) 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 testSetObject118() throws Fault
	{

		Integer maxIntegerVal = null;
		Integer rIntegerVal = null;
		String smaxStringVal = null;

		try
		{
			// to create the Integer Table
			rsSch.createTab("Integer_Tab",sqlp,conn);

			// to update Minimum value column with Maximum value 
			String sPrepStmt = sqlp.getProperty("Integer_Tab_Min_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Maximum Value of Integer to be Updated 
			smaxStringVal = rsSch.extractVal("Integer_Tab",1,sqlp,conn);

			maxIntegerVal = new Integer(smaxStringVal);
			logMsg("Minimum Integer Value: " + maxIntegerVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,maxIntegerVal,java.sql.Types.INTEGER);
			pstmt.executeUpdate();

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

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

			if(rIntegerVal.equals(maxIntegerVal))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Integer_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject119
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Integer_Tab with the minimum (false) value of 
	 *                    Integer_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the minimum (false) 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 testSetObject119() throws Fault
	{
		Integer minIntegerVal = null;
		Integer rIntegerVal = null;
		String sminStringVal = null;
		try
		{
			// to create the Integer Table
			rsSch.createTab("Integer_Tab",sqlp,conn);

			// to update Null value column with Minimum value 
			String sPrepStmt = sqlp.getProperty("Integer_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Minimum Value of Integer to be Updated 
			sminStringVal = rsSch.extractVal("Integer_Tab",2,sqlp,conn);

			minIntegerVal = new Integer(sminStringVal);
			logMsg("Minimum Integer Value: " + minIntegerVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,minIntegerVal,java.sql.Types.INTEGER);
			pstmt.executeUpdate();

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

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

			if(rIntegerVal.equals(minIntegerVal))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Integer_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject120
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Min_Val of Bigint_Tab with the maximum (true) value of 
	 *                    Integer_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the maximum (true) 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 testSetObject120() throws Fault
	{
		Long maxBigintVal = null;
		Integer maxIntegerVal = null;
		Long rBigintVal = null;
		String smaxStringVal = null;

		try
		{
			// to create the Bigint Table
			rsSch.createTab("Bigint_Tab",sqlp,conn);

			// to update Minimum value column with Maximum value 
			String sPrepStmt = sqlp.getProperty("Bigint_Tab_Min_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Maximum Value of Bigint to be Updated 
			smaxStringVal = rsSch.extractVal("Integer_Tab",1,sqlp,conn);

			maxBigintVal = new Long(smaxStringVal);
			maxIntegerVal = new Integer(smaxStringVal);
			logMsg("Maximum Long Value: " + maxIntegerVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,maxIntegerVal,java.sql.Types.BIGINT);
			pstmt.executeUpdate();

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

			Object orBigintVal =  rs.getObject(1);
			rBigintVal = new Long(orBigintVal.toString());
			
			logMsg("Returned Long Value after Updation: " + rBigintVal);
			logMsg("Value returned from ctssql.stmt: " + maxBigintVal);

			if(rBigintVal.equals(maxBigintVal))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Bigint_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject121
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Null_Val of Bigint_Tab with the minimum (false) value of 
	 *                    Integer_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the minimum (false) 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 testSetObject121() throws Fault
	{
		Long minBigintVal = null;
		Integer minIntegerVal = null;
		Long rBigintVal = null;
		String sminStringVal = null;

		try
		{
			// to create the Bigint Table
			rsSch.createTab("Bigint_Tab",sqlp,conn);

			// to update Null value column with Minimum value 
			String sPrepStmt = sqlp.getProperty("Bigint_Tab_Null_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Minimum Value of Bigint to be Updated 
			sminStringVal = rsSch.extractVal("Integer_Tab",2,sqlp,conn);

			minIntegerVal = new Integer(sminStringVal);
			minBigintVal = new Long(sminStringVal);
			logMsg("Minimum Long Value: " + minBigintVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,minIntegerVal,java.sql.Types.BIGINT);
			pstmt.executeUpdate();

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

			Object orBigintVal =  rs.getObject(1);
			rBigintVal = new Long(orBigintVal.toString());
			
			logMsg("Returned Long Value after Updation: " + rBigintVal);
			logMsg("Value returned from ctssql.stmt: " + minBigintVal);

			if(rBigintVal.equals(minBigintVal))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Bigint_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/*
	 * @testName:         testSetObject122
	 * @assertion:        A Prepared Statement object provides a way of calling 
	 *                    precompiled SQL statements.It can take one or more parameters 
	 *                    as input arguments(IN parameters). (See section 11.1.6 of 
	 *                    JDBC 2.0 API Reference & Tutorial,Second Edition)
	 *
	 *                    The drivers must provide full support for Prepared Statement 
	 *                    methods. (See section 6.2.2.3 of Java2 Platform Enterprise 
	 *                    Edition(J2EE) specification v 1.2).
	 *
	 *                    The setObject(int parameterIndex, Object x) 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. 
	 *
	 * @test_Strategy:    Get a PreparedStatement object from the connection to the database.
	 *                    Using the setObject(int parameterIndex, Object x) method,update the 
	 *                    column Min_Val of Real_Tab with the maximum (true) value of 
	 *                    Integer_Tab. Call the getObject(int columnno) method to retrieve this 
	 *                    value. Extract the maximum (true) 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 testSetObject122() throws Fault
	{
		Float maxRealVal = null;
		Integer maxIntegerVal = null;
		Float rRealVal = null;
		String smaxStringVal = null;

		try
		{
			// to create the Real Table
			rsSch.createTab("Real_Tab",sqlp,conn);

			// to update Minimum value column with Maximum value 
			String sPrepStmt = sqlp.getProperty("Real_Tab_Min_Update","");
			logMsg("Prepared Statement String: " + sPrepStmt);

			//to extract the Maximum Value of Float to be Updated 
			smaxStringVal = rsSch.extractVal("Integer_Tab",1,sqlp,conn);

			maxIntegerVal = new Integer(smaxStringVal);
			maxRealVal = new Float(smaxStringVal);
			logMsg("Maximum Real Value: " + maxRealVal);

			// get the PreparedStatement object
			pstmt = conn.prepareStatement(sPrepStmt);
			pstmt.setObject(1,maxIntegerVal,java.sql.Types.REAL);
			pstmt.executeUpdate();

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

			Object orRealVal =  rs.getObject(1);
			rRealVal = new Float(orRealVal.toString());
			
			logMsg("Returned Real Value after Updation: " + rRealVal);
			logMsg("Value returned from ctssql.stmt: " + maxRealVal);

			if(rRealVal.equals(maxRealVal))
			{
				logMsg("setObject Method sets the designated parameter with the Object");
			}
			else
			{
				logErr("setObject Method does not set the designated parameter with the Object");
				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 is Failed!", e);
		}

		finally
		{
			try
			{
				if(rs != null)
				{
					 rs.close();
					 rs = null;
				}
				if(pstmt != null)
				{
					 pstmt.close();
					 pstmt = null;
				}
				if(stmt != null)
				{
					 stmt.close();
					 stmt = null;
				}
				rsSch.dropTab("Real_Tab",conn);
			}
			catch(Exception e){ }
		}
	}



	/* cleanup */
	public void  cleanup() throws Fault
	{
		try
		{
			if(pstmt != null)
			{
				pstmt.close();
				pstmt = null;
			}
			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");
		}
	}
}