text: /*
  Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
  
  The MySQL Connector/C++ is licensed under the terms of the GPLv2
  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
  MySQL Connectors. There are special exceptions to the terms and
  conditions of the GPLv2 as it is applied to this software, see the
  FLOSS License Exception
  <http://www.mysql.com/about/legal/licensing/foss-exception.html>.
  
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published
  by the Free Software Foundation; version 2 of the License.
  
  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  for more details.
  
  You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
  */
  
  
  
  #include "DatabaseMetaDataTest.h"
  
  namespace testsuite
  {
  namespace compliance
  {
  /*
   * @testName:         testAllProceduresAreCallable
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The allProceduresAreCallable method must return a boolean value;
   *                    true if the user has the security rights of calling all the
   *                    procedures returned by the method getProcedures and false
   *                    otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the allProceduresAreCallable() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testAllProceduresAreCallable()
  {
  
    logMsg("Calling allProceduresAreCallable on DatabaseMetaData");
    bool retValue=dbmd->allProceduresAreCallable();
    if (retValue) {
      logMsg(
             "allProceduresAreCallable method called by the current user");
    } else {
      logMsg(
             "allProceduresAreCallable method not called by the current user");
    }
  }
  
  /*
   * @testName:         testAllTablesAreSelectable
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave
   *                    as specified in the JDBC 1.0 and 2.0 specifications. None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The allTablesAreSelectable method must return a boolean value;
   *                    true if the user can use a SELECT statement with all the
   *                    tables returned by the method getTables and false
   *                    otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the allTablesAreSelectable() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testAllTablesAreSelectable()
  {
    logMsg("Calling allTablesAreSelectable on DatabaseMetaData");
    bool retValue=dbmd->allTablesAreSelectable();
    if (retValue) {
      logMsg(
             "allTablesAreSelectable method SELECTed by the current user");
    } else {
      logMsg(
             "allTablesAreSelectable method not SELECTed by the current user");
    }
  }
  
  /*
   * @testName:         testDataDefinitionCausesTransactionCommit
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The dataDefinitionCausesTransactionCommit() method must return
   *                    a boolean value; true if the data definition statement within a
   *                    transaction is forced the transaction to commit and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the dataDefinitionCausesTransactionCommit() method.
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testDataDefinitionCausesTransactionCommit()
  {
    logMsg(
           "Calling DatabaseMetaData.dataDefinitionCausesTransactionCommit");
    bool retValue=dbmd->dataDefinitionCausesTransactionCommit();
    if (retValue) {
      logMsg(
             "Data definition statement forces the transaction to commit");
    } else {
      logMsg(
             "Data definition statement does not forces the transaction to commit");
    }
  }
  
  /*
   * @testName:         testDataDefinitionIgnoredInTransactions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The dataDefinitionIgnoredInTransactions() method must return a
   *                    boolean value; true if a data definition statement within a
   *                    transaction is ignored and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the dataDefinitionIgnoredInTransactions() method.
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testDataDefinitionIgnoredInTransactions()
  {
  
    logMsg(
           "Calling DatabaseMetaData.dataDefinitionIgnoredInTransactions");
    bool retValue=dbmd->dataDefinitionIgnoredInTransactions();
    if (retValue) {
      logMsg("Data definition statement is ignored in a transaction");
    } else {
      logMsg(
             "Data definition statement is not ignored in a transaction");
    }
  
  
  }
  
  /*
   * @testName:         testDeletesAreDetected1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The deletesAreDetected(int resType) method must return a
   *                    boolean value; true if changes are detected by the resultset type
   *                    and false otherwise. The possible values for
   *                    resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
   *                    TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the deletesAreDetected() method on that object with the
   *                    result set type as sql::ResultSet::TYPE_FORWARD_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testDeletesAreDetected1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.deletesAreDetected(TYPE_FORWARD_ONLY)");
    bool retValue=dbmd->deletesAreDetected(sql::ResultSet::TYPE_FORWARD_ONLY);
    if (retValue) {
      logMsg(
             "Visible row delete can be detected for TYPE_FORWARD_ONLY");
    } else {
      logMsg(
             "Visible row delete cannot be detected for TYPE_FORWARD_ONLY");
    }
  
  
  }
  
  /*
   * @testName:         testDeletesAreDetected2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The deletesAreDetected(int resType) method must return a
   *                    boolean value; true if changes are detected by the resultset type
   *                    and false otherwise. The possible values for
   *                    resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
   *                    TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the deletesAreDetected() method on that object with the
   *                    result set type as sql::ResultSet::TYPE_SCROLL_INSENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testDeletesAreDetected2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.deletesAreDetected(TYPE_SCROLL_INSENSITIVE)");
    bool retValue=dbmd->deletesAreDetected(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);
    if (retValue) {
      logMsg(
             "Visible row delete can be detected for TYPE_SCROLL_INSENSITIVE");
    } else {
      logMsg(
             "Visible row delete cannot be detected for TYPE_SCROLL_INSENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testDeletesAreDetected3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The deletesAreDetected(int resType) method must return a
   *                    boolean value; true if changes are detected by the resultset type
   *                    and false otherwise. The possible values for
   *                    resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
   *                    TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the deletesAreDetected() method on that object with the
   *                    result set type as sql::ResultSet::TYPE_SCROLL_SENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testDeletesAreDetected3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.deletesAreDetected(TYPE_SCROLL_SENSITIVE)");
    bool retValue=dbmd->deletesAreDetected(sql::ResultSet::TYPE_SCROLL_SENSITIVE);
    if (retValue) {
      logMsg(
             "Visible row delete can be detected for TYPE_SCROLL_SENSITIVE");
    } else {
      logMsg(
             "Visible row delete cannot be detected for TYPE_SCROLL_SENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testDoesMaxRowSizeIncludeBlobs
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The doesMaxRowSizeIncludeBlobs() method must return a boolean
   *                    value; true if maximum row size includes LONGVARCHAR and
   *                    LONGVARBINARY blobs and false otherwise. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the doesMaxRowSizeIncludeBlobs() method.
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testDoesMaxRowSizeIncludeBlobs()
  {
  
    logMsg("Calling  DatabaseMetaData.doesMaxRowSizeIncludeBlobs");
    bool retValue=dbmd->doesMaxRowSizeIncludeBlobs();
    if (retValue) {
      logMsg("MaxRowSize includes blobs");
    } else {
      logMsg("MaxRowSize does not include blobs");
    }
  
  
  }
  
  /*
   * @testName:         testGetBestRowIdentifier1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getBestRowIdentifier(Str cat, Str sch, Str tab,int scope, boo nflg)
   *                    method must return a ResultSet object with each row is a
   *                    description of a column that belongs to a optimal set of columns
   *                    that uniquely identifies a row.  The possible values for scope
   *                    are bestRowTemporary, bestRowTransaction or bestRowSession
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getBestRowIdentifier() method on that object.
   *                    It should return a ResultSet object.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetBestRowIdentifier1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.getBestRowIdentifier with scope bestRowTemporary with NULLable columns");
  
    ResultSet oRet_ResultSet(dbmd->getBestRowIdentifier(sCatalogName,
                                                        sSchemaName, sFtable, sql::DatabaseMetaData::bestRowTemporary,
                                                        true));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(2) + ",");
    if (sRetStr == "") {
      logMsg(
             "getBestRowIdentifier with scope bestRowTemporary did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetBestRowIdentifier2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getBestRowIdentifier(Str cat, Str sch, Str tab,int scope, boo nflg)
   *                    method must return a ResultSet object with each row is a
   *                    description of a column that belongs to a optimal set of columns
   *                    that uniquely identifies a row.  The possible values for scope
   *                    are bestRowTemporary, bestRowTransaction or bestRowSession
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getBestRowIdentifier() method on that object.
   *                    It should return a ResultSet object.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetBestRowIdentifier2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.getBestRowIdentifier with scope bestRowTransaction with NULLable columns");
    ResultSet oRet_ResultSet(dbmd->getBestRowIdentifier(sCatalogName,
                                                        sSchemaName, sFtable, sql::DatabaseMetaData::bestRowTransaction,
                                                        true));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(2) + ",");
    if (sRetStr == "") {
      logMsg(
             "getBestRowIdentifier with scope bestRowTransaction did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetBestRowIdentifier3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getBestRowIdentifier(Str cat, Str sch, Str tab,int scope, boo nflg)
   *                    method must return a ResultSet object with each row is a
   *                    description of a column that belongs to a optimal set of columns
   *                    that uniquely identifies a row.  The possible values for scope
   *                    are bestRowTemporary, bestRowTransaction or bestRowSession
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getBestRowIdentifier() method on that object.
   *                    It should return a ResultSet object.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetBestRowIdentifier3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.getBestRowIdentifier with scope bestRowSession with NULLable columns");
    ResultSet oRet_ResultSet(dbmd->getBestRowIdentifier(sCatalogName,
                                                        sSchemaName, sFtable, sql::DatabaseMetaData::bestRowSession, true));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(2) + ",");
    if (sRetStr == "") {
      logMsg(
             "getBestRowIdentifier with scope bestRowSession did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetBestRowIdentifier4
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getBestRowIdentifier(Str cat, Str sch, Str tab,int scope, boo nflg)
   *                    method must return a ResultSet object with each row is a
   *                    description of a column that belongs to a optimal set of columns
   *                    that uniquely identifies a row.  The possible values for scope
   *                    are bestRowTemporary, bestRowTransaction or bestRowSession
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getBestRowIdentifier() method on that object.
   *                    It should return a ResultSet object.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetBestRowIdentifier4()
  {
  
    logMsg(
           "Calling DatabaseMetaData.getBestRowIdentifier with scope bestRowTemporary without NULLable columns");
    ResultSet oRet_ResultSet(dbmd->getBestRowIdentifier(sCatalogName,
                                                        sSchemaName, sFtable, sql::ResultSet::TYPE_SCROLL_SENSITIVE,
                                                        false));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(2) + ",");
    if (sRetStr == "") {
      logMsg(
             "getBestRowIdentifier with scope bestRowTemporary did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetBestRowIdentifier5
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getBestRowIdentifier(Str cat, Str sch, Str tab,int scope, boo nflg)
   *                    method must return a ResultSet object with each row is a
   *                    description of a column that belongs to a optimal set of columns
   *                    that uniquely identifies a row.  The possible values for scope
   *                    are bestRowTemporary, bestRowTransaction or bestRowSession
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getBestRowIdentifier() method on that object.
   *                    It should return a ResultSet object.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetBestRowIdentifier5()
  {
  
    logMsg(
           "Calling DatabaseMetaData.getBestRowIdentifier with scope bestRowTransaction without NULLable columns");
    ResultSet oRet_ResultSet(dbmd->getBestRowIdentifier(sCatalogName,
                                                        sSchemaName, sFtable, sql::DatabaseMetaData::bestRowTransaction,
                                                        true));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(2) + ",");
    if (sRetStr == "") {
      logMsg(
             "getBestRowIdentifier with scope bestRowTransaction did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  }
  
  /*
   * @testName:         testGetBestRowIdentifier6
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getBestRowIdentifier(Str cat, Str sch, Str tab,int scope, boo nflg)
   *                    method must return a ResultSet object with each row is a
   *                    description of a column that belongs to a optimal set of columns
   *                    that uniquely identifies a row.  The possible values for scope
   *                    are bestRowTemporary, bestRowTransaction or bestRowSession
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getBestRowIdentifier() method on that object.
   *                    It should return a ResultSet object
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetBestRowIdentifier6()
  {
  
    logMsg(
           "Calling DatabaseMetaData.getBestRowIdentifier with scope bestRowSession without NULLable columns");
    ResultSet oRet_ResultSet(dbmd->getBestRowIdentifier(sCatalogName,
                                                        sSchemaName, sFtable, sql::DatabaseMetaData::bestRowSession, true));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(2) + ",");
    if (sRetStr == "") {
      logMsg(
             "getBestRowIdentifier with scope bestRowSession did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetBestRowIdentifier7
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getBestRowIdentifier(Str cat, Str sch, Str tab,int scope, boo nflg)
   *                    method must return a ResultSet object with each row is a
   *                    description of a column that belongs to a optimal set of columns
   *                    that uniquely identifies a row.  The possible values for scope
   *                    are bestRowTemporary, bestRowTransaction or bestRowSession
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getBestRowIdentifier() method on that object.
   *                    It should return a ResultSet object.
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetBestRowIdentifier7()
  {
    List sColumnNames;
    sColumnNames.push_back("SCOPE");
    sColumnNames.push_back("COLUMN_NAME");
    sColumnNames.push_back("DATA_TYPE");
    sColumnNames.push_back("TYPE_NAME");
    sColumnNames.push_back("COLUMN_SIZE");
    sColumnNames.push_back("BUFFER_LENGTH");
    sColumnNames.push_back("DECIMAL_DIGITS");
    sColumnNames.push_back("PSEUDO_COLUMN");
  
    bool test_status=true;
    logMsg(
           "Calling DatabaseMetaData.getBestRowIdentifier with scope bestRowSession without NULLable columns");
    ResultSet oRet_ResultSet(dbmd->getBestRowIdentifier(sCatalogName,
                                                        sSchemaName, sFtable, sql::DatabaseMetaData::bestRowSession, true));
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
  
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getBestRowIdentifier7 Failed!");
    }
  
  
  }
  
  /*
   * @testName:         testGetCatalogSeparator
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getCatalogSeparator() method must return a String value
   *                    representing the separator string. (See JDK 1.2.2 API
   *                    documentation)
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase.
   *                    Make a call to DatabaseMetadata.getCatalogSeparator() on that object.
   *                    It should return a String and NULL if it is not supported.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetCatalogSeparator()
  {
    logMsg("Calling DatabaseMetaData.getCatalogSeparator");
    String sRetValue=dbmd->getCatalogSeparator();
    if (sRetValue.empty()) {
      logMsg("getCatalogSeparator is not supported");
    } else {
      logMsg(String("getCatalogSeparator returns ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetCatalogTerm
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getCatalogTerm() method must return a String object containing
   *                    the vendor term for "catalog". (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getCatalogTerm() method on that object.
   *                    It should return a String and NULL if it cannot be returned.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetCatalogTerm()
  {
    logMsg("Calling getCatalogTerm on DatabaseMetaData");
    String sRetValue=dbmd->getCatalogTerm();
    if (sRetValue.empty()) {
      logMsg(
             "getCatalogTerm method does not returns the vendor's preferred term for catalog ");
    } else {
      logMsg(String("getCatalogTerm method returns:  ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetCatalogs
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getCatalogs() method must return a ResultSet object with each
   *                    row representing a catalog name available in the database.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getCatalogs() method.
   *                    It should return a ResultSet object
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetCatalogs()
  {
    List sColumnNames;
    sColumnNames.push_back("TABLE_CAT");
    bool test_status=true;
    logMsg("Calling DatabaseMetaData.getCatalogs");
    ResultSet oRet_ResultSet(dbmd->getCatalogs());
    String sRetStr;
    sRetStr="";
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getCatalogs Failed!");
    }
  
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(1) + ",");
    if (sRetStr == "") {
      logMsg("getCatalogs did not return any catalog names");
    } else {
      logMsg("The Catalog names returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  }
  
  /*
   * @testName:         testGetColumnPrivileges
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    getColumnPrivileges(String ctlg,String sch,String tab,String colpat)
   *                    method must return a ResultSet object with each row is a
   *                    description of a column's privileges. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getColumnPrivileges() method on that object.
   *                    It should return a ResultSet object.
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetColumnPrivileges()
  {
  
    List sColumnNames;
    sColumnNames.push_back("TABLE_CAT");
    sColumnNames.push_back("TABLE_SCHEM");
    sColumnNames.push_back("TABLE_NAME");
    sColumnNames.push_back("COLUMN_NAME");
    sColumnNames.push_back("GRANTOR");
    sColumnNames.push_back("GRANTEE");
    sColumnNames.push_back("PRIVILEGE");
    sColumnNames.push_back("IS_GRANTABLE");
  
    bool test_status=true;
    logMsg("Calling DatabaseMetaData.getColumnPrivileges");
    String tmp("%");
    ResultSet oRet_ResultSet(dbmd->getColumnPrivileges(sCatalogName,
                                                       sSchemaName, sFtable, tmp));
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getColumnPrivileges Failed!");
    }
    if (oRet_ResultSet->next()) {
      logMsg("getColumnPrivileges returned some column names");
    } else {
      logMsg("getColumnPrivileges did not return any column names");
    }
  }
  
  /*
   * @testName:         testGetColumns
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getColumns(String clg,String schp,String tnpat,String colNamepat)
   *                    method must return a ResultSet object with each row is a
   *                    description of a table column. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getColumns() method.
   *                    It should return a ResultSet object
   *                          Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetColumns()
  {
  
    List sColumnNames;
  
    sColumnNames.push_back("TABLE_CAT");
    sColumnNames.push_back("TABLE_SCHEM");
    sColumnNames.push_back("TABLE_NAME");
    sColumnNames.push_back("COLUMN_NAME");
    sColumnNames.push_back("DATA_TYPE");
    sColumnNames.push_back("TYPE_NAME");
    sColumnNames.push_back("COLUMN_SIZE");
    sColumnNames.push_back("BUFFER_LENGTH");
    sColumnNames.push_back("DECIMAL_DIGITS");
    sColumnNames.push_back("NUM_PREC_RADIX");
    sColumnNames.push_back("NULLABLE");
    sColumnNames.push_back("REMARKS");
    sColumnNames.push_back("COLUMN_DEF");
    sColumnNames.push_back("SQL_DATA_TYPE");
    sColumnNames.push_back("SQL_DATETIME_SUB");
    sColumnNames.push_back("CHAR_OCTET_LENGTH");
    sColumnNames.push_back("ORDINAL_POSITION");
    sColumnNames.push_back("IS_NULLABLE");
  
    bool test_status=true;
    logMsg("Calling DatabaseMetaData.getColumns");
    String tmp("%");
    ResultSet oRet_ResultSet(dbmd->getColumns(sCatalogName, sSchemaName, tmp, tmp));
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getColumns Failed!");
    }
    if (oRet_ResultSet->next()) {
      logMsg("getColumns returned some column names");
    } else {
      logMsg("getColumns did not return any column names");
    }
  
  
  }
  
  /*
   * @testName:         testGetCrossReference
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getCrossReference(Str prcalg,Str prsch,Str prtab,Str foclg,Str fosch,Str fotab)
   *                    method must return a ResultSet object with each row is a
   *                    description of a foreign key column in a foreign key table.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getCrossReference() method on that object.
   *                    It should return a ResultSet object.
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetCrossReference()
  {
  
    List sColumnNames;
  
    sColumnNames.push_back("PKTABLE_CAT");
    sColumnNames.push_back("PKTABLE_SCHEM");
    sColumnNames.push_back("PKTABLE_NAME");
    sColumnNames.push_back("PKCOLUMN_NAME");
    sColumnNames.push_back("FKTABLE_CAT");
    sColumnNames.push_back("FKTABLE_SCHEM");
    sColumnNames.push_back("FKTABLE_NAME");
    sColumnNames.push_back("FKCOLUMN_NAME");
    sColumnNames.push_back("KEY_SEQ");
    sColumnNames.push_back("UPDATE_RULE");
    sColumnNames.push_back("DELETE_RULE");
    sColumnNames.push_back("FK_NAME");
    sColumnNames.push_back("PK_NAME");
    sColumnNames.push_back("DEFERRABILITY");
  
    bool test_status=true;
    logMsg("Calling DatabaseMetaData.getCrossReference");
    ResultSet oRet_ResultSet(dbmd->getCrossReference(sCatalogName,
                                                     sSchemaName, sPtable, sCatalogName, sSchemaName, sFtable));
    String sRetStr;
    sRetStr="";
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getCrossReference Failed!");
    }
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(8) + ",");
    if (sRetStr == "") {
      logMsg("getCrossReference did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetDatabaseProductName
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The getDatabaseProductName method must return a String object
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getDatabaseProductName() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetDatabaseProductName()
  {
  
    logMsg("Calling getDatabaseProductName on DatabaseMetaData");
    String sRetValue=dbmd->getDatabaseProductName();
    if (sRetValue.empty()) {
      logMsg(
             "getDatabaseProductName method does not returns database product name ");
    } else {
      logMsg(String("getDatabaseProductName method returns:  ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetDatabaseProductVersion
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The getDatabaseProductVersion method must return a String object
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getDatabaseProductVersion() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetDatabaseProductVersion()
  {
  
    logMsg("Calling getDatabaseProductVersion on DatabaseMetaData");
    String sRetValue=dbmd->getDatabaseProductVersion();
    if (sRetValue.empty()) {
      logMsg(
             "getDatabaseProductVersion  method does not returns a database product version ");
    } else {
      logMsg("getDatabaseProductVersion method returns:  "
             + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetDefaultTransactionIsolation
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getDefaultTransactionIsolation() method must return an integer
   *                    value; the value representing the default Transaction Isolation.
   *                    The value can be any one of the following TRANSACTION_NONE,
   *                    TRANSACTION_READ_UNCOMMITTED, TRANSACTION_READ_COMMITTED,
   *                    TRANSACTION_REPEATABLE_READ and TRANSACTION_SERIALIZABLE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getDefaultTransactionIsolation() method.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetDefaultTransactionIsolation()
  {
  
    logMsg("Calling DatabaseMetaData.getDefaultTransactionIsolation");
    int nRetval=dbmd->getDefaultTransactionIsolation();
    if ((nRetval != sql::TRANSACTION_NONE)
        && (nRetval != sql::TRANSACTION_READ_UNCOMMITTED)
        && (nRetval != sql::TRANSACTION_READ_COMMITTED)
        && (nRetval != sql::TRANSACTION_REPEATABLE_READ)
        && (nRetval != sql::TRANSACTION_SERIALIZABLE)) {
      logErr(
             "getDefaultTransactionIsolation returns an invalid value"
             + nRetval);
      FAIL("Call to getDefaultTransactionIsolation is Failed!");
    } else {
      logMsg(
             "getDefaultTransactionIsolation returns a valid Isolation level"
             + nRetval);
    }
  
  
  }
  
  /*
   * @testName:         testGetDriverMajorVersion
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The getDriverMajorVersion method must return a integer value
   *                    representing the driver major version. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getDriverMajorVersion() method
   *                    It should return a Integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetDriverMajorVersion()
  {
    logMsg("Calling getDriverMajorVersion on DatabaseMetaData");
    int drMajorVersion=dbmd->getDriverMajorVersion();
    if (drMajorVersion >= 0) {
      logMsg("getDriverMajorVersion method returns: "
             + drMajorVersion);
    } else {
      logMsg(" getDriverMajorVersion method returns a negative value");
    }
  }
  
  /*
   * @testName:         testGetDriverMinorVersion
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The getDriverMinorVersion method must return a integer value
   *                    representing the driver major version. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getDriverMinorVersion() method
   *                    It should return a Integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetDriverMinorVersion()
  {
    logMsg("Calling getDriverMinorVersion on DatabaseMetaData");
    int drMinorVersion=dbmd->getDriverMinorVersion();
    if (drMinorVersion >= 0) {
      logMsg(" getDriverMinorVersion method returns: "
             + drMinorVersion);
    } else {
      logMsg(
             " getDriverMinorVersion method returns a negative value: "
             + drMinorVersion);
    }
  }
  
  /*
   * @testName:         testGetDriverName
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The getDriverName method must return a String object
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getDriverName() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetDriverName()
  {
  
    logMsg("Calling getDriverName on DatabaseMetaData");
    String sRetValue=dbmd->getDriverName();
    if (sRetValue.empty()) {
      logMsg(
             "getDriverName method does not returns a Driver Name ");
    } else {
      logMsg(String("getDriverName method returns:  ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetDriverVersion
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The getDriverVersion method must return a String object
   *                    representing the driver version including its major and minor
   *                    version numbers. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getDriverVersion() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetDriverVersion()
  {
  
    logMsg("Calling getDriverVersion on DatabaseMetaData");
    String sRetValue=dbmd->getDriverVersion();
    if (sRetValue.empty()) {
      logMsg(
             "getDriverVersion method does not returns a Driver Version ");
    } else {
      logMsg(String("getDriverVersion returns:  ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetExportedKeys
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getExportedKeys(String calg, String sch, String tab)
   *                    method must return a ResultSet object with each row is a
   *                    description of a foreign key that reference a table's primary
   *                    key columns. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getExportedKeys() method on that object.
   *                    It should return a ResultSet object.
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetExportedKeys()
  {
  
    List sColumnNames;
  
    sColumnNames.push_back("PKTABLE_CAT");
    sColumnNames.push_back("PKTABLE_SCHEM");
    sColumnNames.push_back("PKTABLE_NAME");
    sColumnNames.push_back("PKCOLUMN_NAME");
    sColumnNames.push_back("FKTABLE_CAT");
    sColumnNames.push_back("FKTABLE_SCHEM");
    sColumnNames.push_back("FKTABLE_NAME");
    sColumnNames.push_back("FKCOLUMN_NAME");
    sColumnNames.push_back("KEY_SEQ");
    sColumnNames.push_back("UPDATE_RULE");
    sColumnNames.push_back("DELETE_RULE");
    sColumnNames.push_back("FK_NAME");
    sColumnNames.push_back("PK_NAME");
    sColumnNames.push_back("DEFERRABILITY");
  
    bool test_status=true;
    logMsg("Calling DatabaseMetaData.getExportedKeys");
    ResultSet oRet_ResultSet(dbmd->getExportedKeys(sCatalogName,
                                                   sSchemaName, sPtable));
    String sRetStr;
    sRetStr="";
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getExportedKeys Failed!");
    }
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(8) + ",");
    if (sRetStr == "") {
      logMsg("getExportedKeys did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetExtraNameCharacters
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getExtraNameCharacters() method must return a String object
   *                    containing the extra characters; (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getExtraNameCharacters() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetExtraNameCharacters()
  {
  
    logMsg("Calling getExtraNameCharacters on DatabaseMetaData");
    String sRetValue=dbmd->getExtraNameCharacters();
    if (sRetValue.empty()) {
      logMsg(
             "getExtraNameCharacters method does not returns the string containing the extra characters ");
    } else {
      logMsg(String("getExtraNameCharacters method returns: ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetIdentifierQuoteString
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getIdentifierQuoteString() method must return a String
   *                    object representing the quoting string or a space if the database
   *                    does not support quoting identifiers.  A JDBC Compliant driver
   *                    always uses a double quote character ("). (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getIdentifierQuoteString() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetIdentifierQuoteString()
  {
  
    logMsg("Calling getIdentifierQuoteString on DatabaseMetaData");
    String sRetValue=dbmd->getIdentifierQuoteString();
    if (sRetValue == "") {
      logMsg("The database does not support quoting identifiers");
    } else /*if (dynamic_cast<String>( sRetValue ) != NULL)*/
    {
      logMsg(String("getIdentifierQuoteString method returns ") + sRetValue);
    }
    /*
    else if (sRetValue == NULL) {
                    logErr("getIdentifierQuoteString returns an Invalid value");
                    FAIL("Call to getIdentfierQuoteString is Failed!");
                }*/
  }
  
  /*
   * @testName:         testGetImportedKeys
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getImportedKeys(String calg, String sch, String tab)
   *                    method must return a ResultSet object with each row is a
   *                    description of a primary key columns that are referenced by a
   *                    table's foreign key columns. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getImportedKeys() method on that object.
   *                    It should return a ResultSet object.
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetImportedKeys()
  {
  
    List sColumnNames;
  
    sColumnNames.push_back("PKTABLE_CAT");
    sColumnNames.push_back("PKTABLE_SCHEM");
    sColumnNames.push_back("PKTABLE_NAME");
    sColumnNames.push_back("PKCOLUMN_NAME");
    sColumnNames.push_back("FKTABLE_CAT");
    sColumnNames.push_back("FKTABLE_SCHEM");
    sColumnNames.push_back("FKTABLE_NAME");
    sColumnNames.push_back("FKCOLUMN_NAME");
    sColumnNames.push_back("KEY_SEQ");
    sColumnNames.push_back("UPDATE_RULE");
    sColumnNames.push_back("DELETE_RULE");
    sColumnNames.push_back("FK_NAME");
    sColumnNames.push_back("PK_NAME");
    sColumnNames.push_back("DEFERRABILITY");
  
    bool test_status=true;
  
    logMsg("Calling DatabaseMetaData.getImportedKeys");
    ResultSet oRet_ResultSet(dbmd->getImportedKeys(sCatalogName,
                                                   sSchemaName, sFtable));
    String sRetStr;
    sRetStr="";
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getImportedKeys Failed!");
    }
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(4) + ",");
    if (sRetStr == "") {
      logMsg("getImportedKeys did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetIndexInfo1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getIndexInfo(Str calg,Str sch,Str tab,boolean uni,boolean approx)
   *                    method must return a ResultSet object with each row is a
   *                    description of an index column. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getIndexInfo() method on that object.
   *                    It should return a ResultSet object.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetIndexInfo1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.getIndexInfo with approximate data and without accurate results");
    ResultSet oRet_ResultSet(dbmd->getIndexInfo(sCatalogName,
                                                sSchemaName, sFtable, true, true));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(6) + ",");
    if (sRetStr == "") {
      logMsg("getIndexInfo did not return any index names");
    } else {
      logMsg("The index names returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetIndexInfo2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getIndexInfo(Str calg,Str sch,Str tab,boolean uni,boolean approx)
   *                    method must return a ResultSet object with each row is a
   *                    description of an index column. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getIndexInfo() method on that object.
   *                    It should return a ResultSet object.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetIndexInfo2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.getIndexInfo with approximate data and with accurate results");
    ResultSet oRet_ResultSet(dbmd->getIndexInfo(sCatalogName,
                                                sSchemaName, sFtable, true, false));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(6) + ",");
    if (sRetStr == "") {
      logMsg("getIndexInfo did not return any index names");
    } else {
      logMsg("The index names returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetIndexInfo3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getIndexInfo(Str calg,Str sch,Str tab,boolean uni,boolean approx)
   *                    method must return a ResultSet object with each row is a
   *                    description of an index column. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getIndexInfo() method on that object.
   *                    It should return a ResultSet object.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetIndexInfo3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.getIndexInfo without approximate data and with accurate results");
    ResultSet oRet_ResultSet(dbmd->getIndexInfo(sCatalogName,
                                                sSchemaName, sFtable, false, false));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(6) + ",");
    if (sRetStr == "") {
      logMsg("getIndexInfo did not return any index names");
    } else {
      logMsg("The index names returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetIndexInfo4
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getIndexInfo(Str calg,Str sch,Str tab,boolean uni,boolean approx)
   *                    method must return a ResultSet object with each row is a
   *                    description of an index column. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getIndexInfo() method on that object.
   *                    It should return a ResultSet object.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetIndexInfo4()
  {
  
    logMsg(
           "Calling DatabaseMetaData.getIndexInfo without approximate data and without accurate results");
    ResultSet oRet_ResultSet(dbmd->getIndexInfo(sCatalogName,
                                                sSchemaName, sFtable, false, true));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(6) + ",");
    if (sRetStr == "") {
      logMsg("getIndexInfo did not return any index names");
    } else {
      logMsg("The index names returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetIndexInfo5
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getIndexInfo(Str calg,Str sch,Str tab,boolean uni,boolean approx)
   *                    method must return a ResultSet object with each row is a
   *                    description of an index column. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getIndexInfo() method on that object.
   *                    It should return a ResultSet object.
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetIndexInfo5()
  {
    List sColumnNames;
    sColumnNames.push_back("TABLE_CAT");
    sColumnNames.push_back("TABLE_SCHEM");
    sColumnNames.push_back("TABLE_NAME");
    sColumnNames.push_back("NON_UNIQUE");
    sColumnNames.push_back("INDEX_QUALIFIER");
    sColumnNames.push_back("INDEX_NAME");
    sColumnNames.push_back("TYPE");
    sColumnNames.push_back("ORDINAL_POSITION");
    sColumnNames.push_back("COLUMN_NAME");
    sColumnNames.push_back("ASC_OR_DESC");
    sColumnNames.push_back("CARDINALITY");
    sColumnNames.push_back("PAGES");
    sColumnNames.push_back("FILTER_CONDITION");
  
    bool test_status=true;
    logMsg(
           "Calling DatabaseMetaData.getIndexInfo without approximate data and without accurate results");
    ResultSet oRet_ResultSet(dbmd->getIndexInfo(sCatalogName,
                                                sSchemaName, sFtable, false, true));
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getCrossReference Failed!");
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxBinaryLiteralLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxBinaryLiteralLength() method must return a integer
   *                    value; the value representing the maximum number of hex
   *                    characters; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxBinaryLiteralLength() method on that object.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxBinaryLiteralLength()
  {
    logMsg("Calling DatabaseMetaData.getMaxBinaryLiteralLength");
    int nRetval=dbmd->getMaxBinaryLiteralLength();
    if (nRetval < 0) {
      logErr("getMaxBinaryLiteralLength returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxBinaryLiteralLength returns " << nRetval << std::endl;
    }
  }
  
  /*
   * @testName:         testGetMaxCatalogNameLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxCatalogNameLength() method must return an integer
   *                    value; the value representing the maximum catalog name length
   *                    that is allowed; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxCatalogNameLength() method on that object.
   *                    It should return an integer value.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxCatalogNameLength()
  {
    logMsg("Calling DatabaseMetaData.getMaxCatalogNameLength");
    int nRetval=dbmd->getMaxCatalogNameLength();
    if (nRetval < 0) {
      logErr("getMaxCatalogNameLength returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxCatalogNameLength returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxCharLiteralLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxCharLiteralLength() method must return a integer
   *                    value; the value representing the maximum number of
   *                    characters; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxCharLiteralLength() method on that object.
   *                    It should return an integer value.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxCharLiteralLength()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxCharLiteralLength");
    int nRetval=dbmd->getMaxCharLiteralLength();
    if (nRetval < 0) {
      logErr("getMaxCharLiteralLength returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxCharLiteralLength returns " << nRetval << std::endl;
    }
  }
  
  /*
   * @testName:         testGetMaxColumnNameLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxColumnNameLength() method must return a integer
   *                    value; the value representing the maximum number of
   *                    characters allowed as column name length; 0 if there is no limit
   *                    or the limit is unknown. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxColumnNameLength() method on that object.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxColumnNameLength()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxColumnNameLength");
    int nRetval=dbmd->getMaxColumnNameLength();
    if (nRetval < 0) {
      logErr("getMaxColumnNameLength returns a negative value");
    } else {
      TestsListener::messagesLog() <<
              "getMaxColumnNameLength returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxColumnsInGroupBy
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxColumnsInGroupBy() method must return a integer
   *                    value; the value representing the maximum number of
   *                    columns in a GROUP BY clause; 0 if there is no limit or
   *                    the limit is unknown. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxColumnsInGroupBy() method on that object.
   *                    It should return an integer value.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxColumnsInGroupBy()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxColumnsInGroupBy");
    int nRetval=dbmd->getMaxColumnsInGroupBy();
    if (nRetval < 0) {
      logErr("getMaxColumnsInGroupBy returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxColumnsInGroupBy returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxColumnsInIndex
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxColumnsInIndex() method must return a integer
   *                    value; the value representing the maximum number of
   *                    columns in Index; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxColumnsInIndex() method on that object.
   *                    It should return an integer value.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxColumnsInIndex()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxColumnsInIndex");
    int nRetval=dbmd->getMaxColumnsInIndex();
    if (nRetval < 0) {
      logErr("getMaxColumnsInIndex returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxColumnsInIndex returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxColumnsInOrderBy
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxColumnsInOrderBy() method must return a integer
   *                    value; the value representing the maximum number of columns
   *                    in a ORDER BY clause; 0 if there is no limit or the limit is
   *                    unknown. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxColumnsInOrderBy() method on that object.
   *                    It should return an integer value.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxColumnsInOrderBy()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxColumnsInOrderBy");
    int nRetval=dbmd->getMaxColumnsInOrderBy();
    if (nRetval < 0) {
      logErr("getMaxColumnsInOrderBy returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxColumnsInOrderBy returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxColumnsInSelect
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxColumnsInSelect() method must return a integer
   *                    value; the value representing the maximum number of columns in
   *                    a SELECT list; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxColumnsInSelect() method on that object.
   *                    It should return an integer value.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxColumnsInSelect()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxColumnsInSelect");
    int nRetval=dbmd->getMaxColumnsInSelect();
    if (nRetval < 0) {
      logErr("getMaxColumnsInSelect returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxColumnsInSelect returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxColumnsInTable
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxColumnsInTable() method must return a integer
   *                    value; the value representing the maximum number of columns
   *                    in a Table; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxColumnsInTable() method on that object.
   *                    It should return an integer value.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxColumnsInTable()
  {
    logMsg("Calling DatabaseMetaData.getMaxColumnsInTable");
    int nRetval=dbmd->getMaxColumnsInTable();
    if (nRetval < 0) {
      logErr("getMaxColumnsInTable returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxColumnsInTable returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxConnections
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxConnections() method must return a integer
   *                    value; the value representing the maximum number of active
   *                    connections at a time in a database; 0 if there is no limit or
   *                    the limit is unknown. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxConnections() method on that object.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxConnections()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxConnections");
    int nRetval=dbmd->getMaxConnections();
    if (nRetval < 0) {
      logErr("getMaxConnections returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxConnections returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxCursorNameLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxCursorNameLength() method must return a integer
   *                    value; the value representing the maximum cursor name length
   *                    in bytes; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxCursorNameLength() method on that object.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxCursorNameLength()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxCursorNameLength");
    int nRetval=dbmd->getMaxCursorNameLength();
    if (nRetval < 0) {
      logErr("getMaxCursorNameLength returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxCursorNameLength returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxIndexLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxIndexLength() method must return a integer
   *                    value; the value representing the maximum index length in
   *                    bytes; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxIndexLength() method on that object.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxIndexLength()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxIndexLength");
    int nRetval=dbmd->getMaxIndexLength();
    if (nRetval < 0) {
      logErr("getMaxIndexLength returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxIndexLength returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxProcedureNameLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxProcedureNameLength() method must return a integer
   *                    value; the value representing the maximum procedure name length
   *                    that is allowed; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxProcedureNameLength() method on that object.
   *                    It should return an integer value.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxProcedureNameLength()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxProcedureNameLength");
    int nRetval=dbmd->getMaxProcedureNameLength();
    if (nRetval < 0) {
      logErr("getMaxProcedureNameLength returns a negative value");
    } else {
      TestsListener::messagesLog()
              << "getMaxProcedureNameLength returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxRowSize
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxRowSize() method must return a integer
   *                    value; the value representing the maximum length of a single row
   *                    in bytes; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxRowSize() method on that object.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxRowSize()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxRowSize");
    int nRetval=dbmd->getMaxRowSize();
    if (nRetval < 0) {
      logErr("getMaxRowSize returns a negative value");
    } else {
      TestsListener::messagesLog() << "getMaxRowSize returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxSchemaNameLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxSchemaNameLength() method must return a integer
   *                    value; the value representing the maximum schema name length that
   *                    is allowed; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxSchemaNameLength() method on that object.
   *                    It should return an integer value.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxSchemaNameLength()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxSchemaNameLength");
    int nRetval=dbmd->getMaxSchemaNameLength();
    if (nRetval < 0) {
      logErr("getMaxSchemaNameLength returns a negative value");
    } else {
      TestsListener::messagesLog() << "getMaxSchemaNameLength returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxStatementLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxStatementLength() method must return an integer
   *                    value; the value representing the maximum number of characters
   *                    allowed in  SQL statement; 0 if there is no limit or the limit is
   *                    unknown. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxStatementLength() method.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxStatementLength()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxStatementLength");
    int nRetval=dbmd->getMaxStatementLength();
    if (nRetval < 0) {
      logErr("getMaxStatementLength returns a negative value");
    } else {
      TestsListener::messagesLog() << "getMaxStatementLength returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxStatements
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxStatements method must return an integer
   *                    value; the value representing the maximum number of statements
   *                    that can be open at one time to the database; 0 if there is no limit
   *                    or the limit is unknown. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxStatements() method.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxStatements()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxStatements");
    int nRetval=dbmd->getMaxStatements();
    if (nRetval < 0) {
      logErr("getMaxStatements returns a negative value");
    } else {
      TestsListener::messagesLog() << "getMaxStatements returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxTableNameLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxTableNameLength() method must return an integer
   *                    value; the value representing the maximum number of characters
   *                    allowed in a table name; 0 if there is no limit or the limit
   *                    is unknown. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxTableNameLength() method.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxTableNameLength()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxTableNameLength");
    int nRetval=dbmd->getMaxTableNameLength();
    if (nRetval < 0) {
      logErr("getMaxTableNameLength returns a negative value");
    } else {
      TestsListener::messagesLog() << "getMaxTableNameLength returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxTablesInSelect
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxTablesInSelect() method must return an integer
   *                    value; the value representing the maximum number of tables in
   *                    SELECT clause; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxTablesInSelect() method.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxTablesInSelect()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxTablesInSelect");
    int nRetval=dbmd->getMaxTablesInSelect();
    if (nRetval < 0) {
      logErr("getMaxTablesInSelect returns a negative value");
    } else {
      TestsListener::messagesLog() << "getMaxTablesInSelect returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetMaxUserNameLength
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getMaxUserNameLength() method must return an integer
   *                    value; the value representing the maximum of characters allowed
   *                    in a user name; 0 if there is no limit or the limit is unknown.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getMaxUserNameLength() method.
   *                    It should return an integer value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetMaxUserNameLength()
  {
  
    logMsg("Calling DatabaseMetaData.getMaxUserNameLength");
    int nRetval=dbmd->getMaxUserNameLength();
    if (nRetval < 0) {
      logErr("getMaxUserNameLength returns a negative value");
    } else {
      TestsListener::messagesLog() << "getMaxUserNameLength returns " << nRetval << std::endl;
    }
  
  
  }
  
  /*
   * @testName:         testGetNumericFunctions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getNumericFunctions() method must return a String object
   *                    that is a comma separated list of math functions; These are
   *                    the X/Open CLI math function names used in the JDBC function
   *                    escape clause. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the  getNumericFunctions() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetNumericFunctions()
  {
  
    logMsg("Calling getNumericFunctions on DatabaseMetaData");
    String sRetValue=dbmd->getNumericFunctions();
    if (sRetValue.empty()) {
      logMsg(
             "getNumericFunctions method does not returns the comma-separated list of math functions ");
    } else {
      logMsg(String("getNumericFunctions method returns: ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetPrimaryKeys
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getPrimaryKeys(String calg, String sch, String tab)
   *                    method must return a ResultSet object with each row is a
   *                    description of the given table's primary key column(s).
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getPrimaryKeys() method on that object.
   *                    It should return a ResultSet object.
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetPrimaryKeys()
  {
  
    List sColumnNames;
  
    sColumnNames.push_back("TABLE_CAT");
    sColumnNames.push_back("TABLE_SCHEM");
    sColumnNames.push_back("TABLE_NAME");
    sColumnNames.push_back("COLUMN_NAME");
    sColumnNames.push_back("KEY_SEQ");
    sColumnNames.push_back("PK_NAME");
  
    bool test_status=true;
    logMsg("Calling DatabaseMetaData.getPrimaryKeys");
    ResultSet oRet_ResultSet(dbmd->getPrimaryKeys(sCatalogName,
                                                  sSchemaName, sFtable));
    String sRetStr;
    sRetStr="";
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getPrimaryKeys Failed!");
    }
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(4) + ",");
    if (sRetStr == "") {
      logMsg("getPrimaryKeys did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  
  #ifdef INCLUDE_NOT_IMPLEMENTED_METHODS
  /*
   * @testName:         testGetProcedureColumns
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getProcedureColumns(Str ctlg,Str schp,String prp,String colpa)
   *                    method must return a ResultSet object with each row describes
   *                    the information like parameter for the stored procedure,
   *                    return value of the stored procedure, etc.,
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getProcedureColumns() method.
   *                    It should return a ResultSet object
   *                      Validate the column names and column ordering.
   */
  /* throws Exception */
  void DatabaseMetaDataTest::testGetProcedureColumns()
  {
    if (hasSps) {
  
      List sColumnNames;
  
      sColumnNames.push_back("PROCEDURE_CAT");
      sColumnNames.push_back("PROCEDURE_SCHEM");
      sColumnNames.push_back("PROCEDURE_NAME");
      sColumnNames.push_back("COLUMN_NAME");
      sColumnNames.push_back("COLUMN_TYPE");
      sColumnNames.push_back("DATA_TYPE");
      sColumnNames.push_back("TYPE_NAME");
      sColumnNames.push_back("PRECISION");
      sColumnNames.push_back("LENGTH");
      sColumnNames.push_back("SCALE");
      sColumnNames.push_back("RADIX");
      sColumnNames.push_back("NULLABLE");
      sColumnNames.push_back("REMARKS");
  
      bool test_status=true;
  
      logMsg("Calling DatabaseMetaData.getProcedureColumns");
      String tmp("%");
      ResultSet oRet_ResultSet(dbmd->getProcedureColumns(sCatalogName, sSchemaName, tmp, tmp));
      String sRetStr;
      sRetStr="";
      test_status=columnCompare(sColumnNames, oRet_ResultSet);
      if (test_status == false)
      {
        logMsg(
               "Columns return are not same either in order or name");
        FAIL("Call to getProcedureColumns Failed!");
      }
      if (oRet_ResultSet->next())
      {
        logMsg("getProcedureColumns returned some column names");
      } else {
        logMsg(
               "getProcedureColumns did not return any column names");
      }
    }
  }
  #endif
  
  /*
   * @testName:         testGetProcedureTerm
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getProcedureTerm() method must return a String object
   *                    containing the vendor term for "procedure".  (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getProcedureTerm() method on that object.
   *                    It should return a String and NULL if it cannot be generated.;
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetProcedureTerm()
  {
  
    logMsg("Calling getProcedureTerm on DatabaseMetaData");
    String sRetValue=dbmd->getProcedureTerm();
    if (sRetValue.empty()) {
      logMsg(
             "getProcedureTerm method does not returns the vendor's preferred term for procedure ");
    } else {
      logMsg(String("getProcedureTerm method returns:  ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetProcedures
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getProcedures(String catg, String schemapat, String procpat)
   *                    method must return a ResultSet object where catg is the catalog
   *                    name, schemapat is schema pattern and procpat is procedure name
   *                    pattern.  Each row of the ResultSet is the description of the.
   *                    stored procedure. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getProcedures() method.
   *                    It should return a ResultSet object
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetProcedures()
  {
    if (!this->hasSps) {
      return;
    }
  
    List sColumnNames;
  
    sColumnNames.push_back("PROCEDURE_CAT");
    sColumnNames.push_back("PROCEDURE_SCHEM");
    sColumnNames.push_back("PROCEDURE_NAME");
    sColumnNames.push_back("RESERVED1");
    sColumnNames.push_back("RESERVED2");
    sColumnNames.push_back("RESERVED3");
    sColumnNames.push_back("REMARKS");
    sColumnNames.push_back("PROCEDURE_TYPE");
  
    bool  statusColumnCount=  true;
    bool  statusColumnMatch=  true;
    int   iColumnNamesLength= static_cast<int>(sColumnNames.size());
  
    logMsg("Calling DatabaseMetaData.getProcedures");
  
    String tmp("%");
  
    ResultSet oRet_ResultSet(dbmd->getProcedures(sCatalogName, sSchemaName, tmp));
    String sRetStr;
  
    sRetStr="";
    ResultSetMetaData rsmd(oRet_ResultSet->getMetaData());
  
    int iCount=rsmd->getColumnCount();
    TestsListener::messagesLog()
            << "Minimum Column Count is:" << iColumnNamesLength << std::endl;
    if (iColumnNamesLength <= iCount) {
      iCount=iColumnNamesLength;
      statusColumnCount=true;
    } else {
      statusColumnCount=false;
    }
    logMsg("Comparing Column Names...");
  
    while (iColumnNamesLength > 0) {
      if ((iCount < 4) || (iCount > 6))
      {
        if (ciString(sColumnNames[iColumnNamesLength - 1].c_str())
            == rsmd->getColumnName(iCount).c_str())
        {
          statusColumnMatch=true;
        } else
        {
          statusColumnMatch=false;
          break;
        }
      }
  
      iCount--;
      iColumnNamesLength--;
    }
    if ((statusColumnCount == false) || (statusColumnMatch == false)) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getProcedures Failed!");
    }
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(3) + ",");
    if (sRetStr == "") {
      logMsg("getProcedures did not return any procedure names");
    } else {
      logMsg("The Procedure names returned are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  }
  
  /*
   * @testName:         testGetSQLKeywords
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getSQLKeywords() method must return a String object that is
   *                    comma separated list of keywords used by the database that are
   *                    not also SQL-92 keywords.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the  getSQLKeywords() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetSQLKeywords()
  {
  
    logMsg("Calling getSQLKeywords on DatabaseMetaData");
    String sRetValue=dbmd->getSQLKeywords();
    if (sRetValue.empty()) {
      logMsg(
             "getSQLKeywords method does not returns the list of SQLKeywords ");
    } else {
      logMsg(String("getSQLKeywords method returns: ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetSchemaTerm
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getSchemaTerm() method must return a String object representing
   *                    the vendor term for "schema". (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getSchemaTerm() method on that object.
   *                    It should return a String and NULL if it cannot be generated.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetSchemaTerm()
  {
    logMsg("Calling getSchemaTerm on DatabaseMetaData");
    String sRetValue=dbmd->getSchemaTerm();
    if (sRetValue.empty()) {
      logMsg(
             "getSchemaTerm method does not returns the vendor's preferred term for schema ");
    } else {
      logMsg(String("getSchemaTerm method returns:  ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetSchemas
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getSchemas() method must return a ResultSet object, with each row
   *                    representing a schema name available in the database
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getSchemas() method.
   *                    It should return a ResultSet object
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetSchemas()
  {
    List sColumnNames;
    sColumnNames.push_back("TABLE_SCHEM");
  
    bool test_status=true;
  
    logMsg("Calling DatabaseMetaData.getSchemas");
  
    ResultSet oRet_ResultSet(dbmd->getSchemas());
  
    String sRetStr;
    sRetStr="";
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getSchemas Failed!");
    }
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(1) + ",");
    if (sRetStr == "") {
      logMsg("getSchemas did not return any schema names");
    } else {
      logMsg("The Schema names returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetSearchStringEscape
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getSystemFunctions() method must return a String object
   *                    used to escape wildcard characters; (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getSearchStringEscape() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetSearchStringEscape()
  {
  
    logMsg("Calling getSearchStringEscape on DatabaseMetaData");
    String sRetValue=dbmd->getSearchStringEscape();
    if (sRetValue.empty()) {
      logMsg(
             "getSearchStringEscape  method does not returns the string used to escape wildcard characters ");
    } else {
      logMsg(String("getSearchStringEscape method returns: ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetStringFunctions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getStringFunctions() method must return a String object
   *                    that is a comma separated list of string functions; These are
   *                    the X/Open CLI string function names used in the JDBC function
   *                    escape clause. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getStringFunctions() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetStringFunctions()
  {
  
    logMsg("Calling getStringFunctions on DatabaseMetaData");
    String sRetValue=dbmd->getStringFunctions();
    if (sRetValue.empty()) {
      logMsg(
             "getStringFunctions method does not returns the comma-separated list of string functions ");
    } else {
      logMsg(String("getStringFunctions method returns: ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetSystemFunctions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getSystemFunctions() method must return a String object
   *                    that is a comma separated list of string functions; These are
   *                    the X/Open CLI system function names used in the JDBC function
   *                    escape clause. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getSystemFunctions() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetSystemFunctions()
  {
  
    logMsg("Calling getSystemFunctions on DatabaseMetaData");
    String sRetValue=dbmd->getSystemFunctions();
    if (sRetValue.empty()) {
      logMsg(
             "getSystemFunctions methd does not returns the comma-separated list of system functions ");
    } else {
      logMsg(String("getSystemFunctions method returns: ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetTablePrivileges
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    getTablePrivileges(String clg,String schpat,String tabnamepat)
   *                    method must return a ResultSet object with each row is a
   *                    description of the access rights for a table. (See JDK 1.2.2
   *                    API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getTablePrivileges() method on that object.
   *                    It should return a ResultSet object.
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetTablePrivileges()
  {
    List sColumnNames;
  
    sColumnNames.push_back("TABLE_CAT");
    sColumnNames.push_back("TABLE_SCHEM");
    sColumnNames.push_back("TABLE_NAME");
    sColumnNames.push_back("GRANTOR");
    sColumnNames.push_back("GRANTEE");
    sColumnNames.push_back("PRIVILEGE");
    sColumnNames.push_back("IS_GRANTABLE");
  
    bool test_status=true;
  
    logMsg("Calling DatabaseMetaData.getTablePrivileges");
  
    ResultSet oRet_ResultSet(dbmd->getTablePrivileges(sCatalogName,
                                                      sSchemaName, sFtable));
    String sRetStr;
    sRetStr="";
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getTablePrivileges Failed!");
    }
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(6) + ",");
    if (sRetStr == "") {
      logMsg("getTablePrivileges did not return any privileges");
    } else {
      logMsg("The privileges returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetTableTypes
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getTableTypes() method must return a ResultSet object with each
   *                    row representing a table type available in the DBMS.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getTableTypes() method.
   *                    It should return a ResultSet object
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetTableTypes()
  {
    List sColumnNames;
    sColumnNames.push_back("TABLE_TYPE");
  
    bool test_status=true;
  
    logMsg("Calling DatabaseMetaData.getTableTypes");
  
    ResultSet oRet_ResultSet(dbmd->getTableTypes());
    String sRetStr;
    sRetStr="";
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
  
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getTableTypes Failed!");
    }
  
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(1) + ",");
  
    if (sRetStr == "") {
      logMsg("getTableTypes did not return any table types");
    } else {
      logMsg("The Table Types returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetTables
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getTables() method must return a ResultSet object
   *                    with each row is a description of the table
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getTables() method.
   *                    It should return a ResultSet object
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetTables()
  {
    List sColumnNames;
  
    sColumnNames.push_back("TABLE_CAT");
    sColumnNames.push_back("TABLE_SCHEM");
    sColumnNames.push_back("TABLE_NAME");
    sColumnNames.push_back("TABLE_TYPE");
    sColumnNames.push_back("REMARKS");
  
    bool test_status=true;
  
    logMsg("Calling DatabaseMetaData.getTables");
    String tmp("%");
    std::list< sql::SQLString > tmp2;
    ResultSet oRet_ResultSet(dbmd->getTables(sCatalogName, sSchemaName, tmp, tmp2));
  
    String sRetStr;
    sRetStr="";
  
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
  
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getTables Failed!");
    }
  
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(3) + ",");
  
    if (sRetStr == "") {
      logMsg("getTables did not return any table names");
    } else {
      logMsg("The Table names returned are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  }
  
  /*
   * @testName:         testGetTimeDateFunctions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getSystemFunctions method must return a String object
   *                    that is a comma separated list of time and date functions;
   *                    These are the X/Open CLI time and date function names used
   *                    in the JDBC function escape clause. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getTimeDateFunctions() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetTimeDateFunctions()
  {
  
    logMsg("Calling getTimeDateFunctions on DatabaseMetaData");
    String sRetValue=dbmd->getTimeDateFunctions();
    if (sRetValue.empty()) {
      logMsg(
             "getTimeDateFunctions method does not returns the comma-separated list of time and date functions ");
    } else {
      logMsg(String("getTimeDateFunctions method returns: ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetTypeInfo
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getTypeInfo() method must return a ResultSet object with each
   *                    row is a description of a local DBMS type.  (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getTypeInfo() method on that object.
   *                    It should return a ResultSet object
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetTypeInfo()
  {
    List sColumnNames;
  
    sColumnNames.push_back("TYPE_NAME");
    sColumnNames.push_back("DATA_TYPE");
    sColumnNames.push_back("PRECISION");
    sColumnNames.push_back("LITERAL_PREFIX");
    sColumnNames.push_back("LITERAL_SUFFIX");
    sColumnNames.push_back("CREATE_PARAMS");
    sColumnNames.push_back("NULLABLE");
    sColumnNames.push_back("CASE_SENSITIVE");
    sColumnNames.push_back("SEARCHABLE");
    sColumnNames.push_back("UNSIGNED_ATTRIBUTE");
    sColumnNames.push_back("FIXED_PREC_SCALE");
    sColumnNames.push_back("AUTO_INCREMENT");
    sColumnNames.push_back("LOCAL_TYPE_NAME");
    sColumnNames.push_back("MINIMUM_SCALE");
    sColumnNames.push_back("MAXIMUM_SCALE");
    sColumnNames.push_back("SQL_DATA_TYPE");
    sColumnNames.push_back("SQL_DATETIME_SUB");
    sColumnNames.push_back("NUM_PREC_RADIX");
  
    bool    statusColumnMatch= true;
    bool    statusColumnCount= true;
    String  sRetStr("");
  
    int     iColumnNamesLength= static_cast<int>(sColumnNames.size());
  
    logMsg("Calling DatabaseMetaData.getTypeInfo");
  
    ResultSet oRet_ResultSet(dbmd->getTypeInfo());
  
    ResultSetMetaData rsmd(oRet_ResultSet->getMetaData());
  
    int iCount=rsmd->getColumnCount();
    TestsListener::messagesLog()
            << "Minimum Column Count is:" << iColumnNamesLength << std::endl;
  
    if (iColumnNamesLength > iCount) {
      statusColumnCount=false;
    } else if (iColumnNamesLength < iCount) {
      iCount=iColumnNamesLength;
      statusColumnCount=true;
    } else {
      statusColumnCount=true;
    }
  
    logMsg("Comparing Column Names...");
  
    while (iColumnNamesLength > 0) {
      if (ciString(sColumnNames[iColumnNamesLength - 1].c_str())
          == rsmd->getColumnName(iCount).c_str())
      {
        statusColumnMatch=true;
      } else {
        statusColumnMatch=false;
        break;
      }
      iCount--;
      iColumnNamesLength--;
    }
    if ((statusColumnMatch == false) && (statusColumnCount == true)) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getTypeInfo Failed!");
    }
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(1) + ",");
    if (sRetStr == "") {
      logMsg("getTypeInfo did not return any type names");
    } else {
      logMsg(String("The Type names returned are : ") + sRetStr);
    }
  
  
  }
  
  /*
   * @testName:         testGetUDTs
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getUDTs() method must return a ResultSet object with each
   *                    row is a description of a UDT (User Defined Type).
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getUDTs() method on that object.
   *                    It should return a ResultSet object.
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetUDTs()
  {
  
    logMsg("Calling DatabaseMetaData.getUDTs");
    String tmp("%");
    std::list<int> tmp2;
    ResultSet oRet_ResultSet(dbmd->getUDTs(sCatalogName, sSchemaName, tmp, tmp2));
    String sRetStr;
    sRetStr="";
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(3) + ",");
    if (sRetStr == "") {
      logMsg("getUDTs did not return any user defined types");
    } else {
      logMsg("The type names returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testGetUDTs01
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getUDTs() method must return a ResultSet object with each
   *                    row is a description of a UDT (User Defined Type).
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getUDTs() method on that object.
   *                    It should return a ResultSet object.
   *                      Validate the column names and column ordering.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetUDTs01()
  {
    List sColumnNames;
  
    sColumnNames.push_back("TYPE_CAT");
    sColumnNames.push_back("TYPE_SCHEM");
    sColumnNames.push_back("TYPE_NAME");
    sColumnNames.push_back("CLASS_NAME");
    sColumnNames.push_back("DATA_TYPE");
    sColumnNames.push_back("REMARKS");
  
    bool statusColumnMatch=true;
    bool statusColumnCount=true;
    String sRetStr;
  
    sRetStr="";
    int iColumnNamesLength= static_cast<int>( sColumnNames.size() );
    logMsg("Calling DatabaseMetaData.getUDTs");
  
    String tmp("%");
    std::list<int> tmp2;
  
    ResultSet oRet_ResultSet(dbmd->getUDTs(sCatalogName, sSchemaName, tmp, tmp2));
    ResultSetMetaData rsmd(oRet_ResultSet->getMetaData());
  
    int iCount=rsmd->getColumnCount();
  
    TestsListener::messagesLog()
            << "Minimum Column Count is:" << iColumnNamesLength << std::endl;
  
    if (iColumnNamesLength > iCount) {
      statusColumnCount=false;
      logMsg("Different number of columns");
      }
      else if (iColumnNamesLength < iCount)
      {
          iCount = iColumnNamesLength;
      }
  
    logMsg("Comparing Column Names...");
  
    while (iColumnNamesLength > 0) {
      if (ciString(sColumnNames[iColumnNamesLength - 1].c_str())
          == rsmd->getColumnName(iCount).c_str())
      {
        statusColumnMatch=true;
      } else {
        statusColumnMatch=false;
        logMsg("Different columns, dumping expected and returned");
        logMsg(sColumnNames[iColumnNamesLength - 1]);
        logMsg(rsmd->getColumnName(iCount));
        break;
          }
          --iCount;
          --iColumnNamesLength;
      }
  
    if ((statusColumnMatch == false) && (statusColumnCount == true)) {
      logMsg("Column names or order wrong.");
      FAIL("Call to getUDTs Failed!");
    }
  
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(3) + ",");
    if (sRetStr == "") {
      logMsg("getUDTs did not return any user defined types");
    } else {
      logMsg("The type names returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  
  #ifdef INCLUDE_NOT_IMPLEMENTED_METHODS
  /*
   * @testName:         testGetURL
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave
   *                    as specified in the JDBC 1.0 and 2.0 specifications. None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The getURL method must return a String object representing the
   *                    URL for the database; null if it cannot be generated.
   *                    (See JDK 1.2.2 API documentation).
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getURL() method
   *                    It should return a String or null if it cannot be generated
   *
   */
  /* throws Exception */
  void DatabaseMetaDataTest::testGetURL()
  {
    logMsg("Calling getURL on DatabaseMetaData");
    String sRetValue=dbmd->getURL();
    if (sRetValue.empty()) {
      logMsg("getURL method return a NULL value ");
    } else {
      logMsg(String("getURL method returns:  ") + sRetValue);
    }
  }
  #endif
  
  
  /*
   * @testName:         testGetUserName
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The getUserName method must return a String object representing
   *                    the Username of the database. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the getUserName() method
   *                    It should return a String
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetUserName()
  {
  
    logMsg("Calling getUserName on DatabaseMetaData");
    String sRetValue=dbmd->getUserName();
    if (sRetValue.empty()) {
      logMsg("getUserName method does not returns user name ");
    } else {
      logMsg(String("getUserName method returns: ") + sRetValue);
    }
  }
  
  /*
   * @testName:         testGetVersionColumns
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The getVersionColumns(String calg, String sch, String tab)
   *                    method must return a ResultSet object with each row is a
   *                    description of a table column that is automatically updated
   *                    whenever a value in a row is updated.  (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the getVersionColumns() method on that object.
   *                    It should return a ResultSet object.Compare the column names
   *                      Validate the column names and column ordering.
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testGetVersionColumns()
  {
  
    List sColumnNames;
  
    sColumnNames.push_back("SCOPE");
    sColumnNames.push_back("COLUMN_NAME");
    sColumnNames.push_back("DATA_TYPE");
    sColumnNames.push_back("TYPE_NAME");
    sColumnNames.push_back("COLUMN_SIZE");
    sColumnNames.push_back("BUFFER_LENGTH");
    sColumnNames.push_back("DECIMAL_DIGITS");
    sColumnNames.push_back("PSEUDO_COLUMN");
  
    bool test_status=true;
  
    logMsg("Calling DatabaseMetaData.getVersionColumns");
  
    ResultSet oRet_ResultSet(dbmd->getVersionColumns(sCatalogName,
                                                     sSchemaName, sFtable));
  
    String sRetStr;
    sRetStr="";
    test_status=columnCompare(sColumnNames, oRet_ResultSet);
    if (test_status == false) {
      logMsg("Columns return are not same either in order or name");
      FAIL("Call to getVersionColumns Failed!");
    }
    while (oRet_ResultSet->next())
      sRetStr+=(oRet_ResultSet->getString(2) + ",");
    if (sRetStr == "") {
      logMsg("getVersionColumns did not return any columns");
    } else {
      logMsg("The columns returned Are : "
             + sRetStr.substr(0, sRetStr.length() - 1));
    }
  
  
  }
  
  /*
   * @testName:         testInsertsAreDetected1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The insertsAreDetected(int resType) method must return a
   *                    boolean value; true if the method ResultSet.rowInserted returns
   *                    true when called on a ResultSet object with a given type that
   *                    contains visible row insertion; false if the method
   *                    ResultSet.rowInserted returns false. The possible values for
   *                    resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
   *                    TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the insertsAreDetected() method on that object with the
   *                    result set type as sql::ResultSet::TYPE_FORWARD_ONLY.
   *                    It should return a boolean value; either or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testInsertsAreDetected1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.insertsAreDetected(TYPE_FORWARD_ONLY)");
    bool retValue=dbmd->insertsAreDetected(sql::ResultSet::TYPE_FORWARD_ONLY);
    if (retValue) {
      logMsg(
             "Visible row insert can be detected for TYPE_FORWARD_ONLY");
    } else {
      logMsg(
             "Visible row insert cannot be detected for TYPE_FORWARD_ONLY");
    }
  
  
  }
  
  /*
   * @testName:         testInsertsAreDetected2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The insertsAreDetected(int resType) method must return a
   *                    boolean value; true if the method ResultSet.rowInserted returns
   *                    true when called on a ResultSet object with a given type that
   *                    contains visible row insertion; false if the method
   *                    ResultSet.rowInserted returns false. The possible values for
   *                    resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
   *                    TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the insertsAreDetected() method on that object with the
   *                    result set type as sql::ResultSet::TYPE_SCROLL_INSENSITIVE.
   *                    It should return a boolean value; either or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testInsertsAreDetected2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.insertsAreDetected(TYPE_SCROLL_INSENSITIVE)");
    bool retValue=dbmd->insertsAreDetected(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);
    if (retValue) {
      logMsg(
             "Visible row insert can be detected for TYPE_SCROLL_INSENSITIVE");
    } else {
      logMsg(
             "Visible row insert cannot be detected for TYPE_SCROLL_INSENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testInsertsAreDetected3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The insertsAreDetected(int resType) method must return a
   *                    boolean value; true if the method ResultSet.rowInserted returns
   *                    true when called on a ResultSet object with a given type that
   *                    contains visible row insertion; false if the method
   *                    ResultSet.rowInserted returns false. The possible values for
   *                    resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
   *                    TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the insertsAreDetected() method on that object with the
   *                    result set type as sql::ResultSet::TYPE_SCROLL_SENSITIVE.
   *                    It should return a boolean value; either or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testInsertsAreDetected3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.insertsAreDetected(TYPE_SCROLL_SENSITIVE)");
    bool retValue=dbmd->insertsAreDetected(sql::ResultSet::TYPE_SCROLL_SENSITIVE);
    if (retValue) {
      logMsg(
             "Visible row insert can be detected for TYPE_SCROLL_SENSITIVE");
    } else {
      logMsg(
             "Visible row insert cannot be detected for TYPE_SCROLL_SENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testIsCatalogAtStart
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The isCatalogAtStart() method must return a boolean value;
   *                    true if the catalog name appears at the start of a fully
   *                    qualified table name; false if it appears at the end.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the isCatalogAtStart() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testIsCatalogAtStart()
  {
  
    logMsg("Calling isCatalogAtStart on DatabaseMetaData");
    bool retValue=dbmd->isCatalogAtStart();
    if (retValue) {
      logMsg(
             "isCatalogAtStart metohd returns catalog appear at the start");
    } else {
      logMsg(
             "isCatalogAtStart metohd returns catalog appear at the end");
    }
  }
  
  /*
   * @testName:         testIsReadOnly
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The isReadOnly method must return a boolean value; true if
   *                    the database is in read-only mode and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the isReadOnly() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testIsReadOnly()
  {
  
    logMsg("Calling isReadOnly on DatabaseMetaData");
    bool retValue=dbmd->isReadOnly();
    if (retValue) {
      logMsg("IsReadOnly method is in read-only mode");
    } else {
      logMsg("IsReadOnly method is not in read-only mode");
    }
  }
  
  /*
   * @testName:         testNullPlusNonNullIsNull
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The nullPlusNonNullIsNull() method must return a boolean value;
   *                    true if the concatenation of a NULL value and a non-NULL value
   *                    results in a NULL value and false otherwise.  A JDBC compliant
   *                    driver must always return true. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the nullPlusNonNullIsNull() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testNullPlusNonNullIsNull()
  {
    logMsg("Calling nullPlusNonNullIsNull on DatabaseMetaData");
  
    bool retValue=dbmd->nullPlusNonNullIsNull();
  
    if (retValue) {
      logMsg(
             "nullPlusNonNullIsNull method returns a NULL value for the concatenations between NULL and non-NULL");
    } else {
      logMsg(
             "nullPlusNonNullIsNull method does not returns a NULL value for the concatenations between NULL and non-NULL");
      FAIL("nullPlusNonNullIsNull method should always return true!");
    }
  }
  
  /*
   * @testName:         testNullsAreSortedAtEnd
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The nullsAreSortedAtEnd method must return a boolean value;
   *                    true if NULL values are sorted at the end regardless of the
   *                    sort order and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the nullsAreSortedAtEnd() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testNullsAreSortedAtEnd()
  {
  
    logMsg("Calling NullsAreSortedAtEnd on DatabaseMetaData");
    bool retValue=dbmd->nullsAreSortedAtEnd();
    if (retValue) {
      logMsg(
             "nullsAreSortedAtEnd method returns NULL values sorted at the end");
    } else {
      logMsg(
             "nullsAreSortedAtEnd method returns NULL values not sorted at the end");
    }
  }
  
  /*
   * @testName:         testNullsAreSortedAtStart
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The nullsAreSortedAtStart method must return a boolean value;
   *                    true if NULL values are sorted at the start regardless of the
   *                    sort order and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the nullsAreSortedAtStart() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testNullsAreSortedAtStart()
  {
  
    logMsg("Calling nullsAreSortedAtStart on DatabaseMetaData");
    bool retValue=dbmd->nullsAreSortedAtStart();
    if (retValue) {
      logMsg(
             "nullsAreSortedAtStart method returns NULL values sorted at the start");
    } else {
      logMsg(
             "nullsAreSortedAtStart method returns NULL values not sorted at the start");
    }
  }
  
  /*
   * @testName:         testNullsAreSortedHigh
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The nullsAreSortedHigh method must return a boolean value;
   *                    true if NULL values are sorted high and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the nullsAreSortedHigh() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testNullsAreSortedHigh()
  {
  
    logMsg("Calling nullsAreSortedHigh on DatabaseMetaData");
    bool retValue=dbmd->nullsAreSortedHigh();
    if (retValue) {
      logMsg(
             "nullsAreSortedHigh method returns NULL values sorted  high");
    } else {
      logMsg(
             "nullsAreSortedHigh method returns NULL values not sorted high");
    }
  }
  
  /*
   * @testName:         testNullsAreSortedLow
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The nullsAreSortedLow method must return a boolean value;
   *                    true if NULL values are sorted low and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the nullsAreSortedLow() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testNullsAreSortedLow()
  {
    logMsg("Calling nullsAreSortedLow on DatabaseMetaData");
    bool retValue=dbmd->nullsAreSortedLow();
    if (retValue) {
      logMsg(
             "nullsAreSortedLow method returns NULL values sorted low");
    } else {
      logMsg(
             "nullsAreSortedLow method returns NULL values not sorted low");
    }
  }
  
  /*
   * @testName:         testOthersDeletesAreVisible1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The othersDeletesAreVisible(int resType) method must return a
   *                    boolean value; true if a rows deleted by others are visible and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the otherDeletesAreVisible(int resType) method on that
   *                    object with sql::ResultSet::TYPE_FORWARD_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOthersDeletesAreVisible1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.othersDeletesAreVisible(TYPE_FORWARD_ONLY)");
    bool retValue=dbmd->othersDeletesAreVisible(sql::ResultSet::TYPE_FORWARD_ONLY);
    if (retValue) {
      logMsg(
             "Deletes made by others are visible for TYPE_FORWARD_ONLY");
    } else {
      logMsg(
             "Deletes made by others are not visible for TYPE_FORWARD_ONLY");
    }
  
  
  }
  
  /*
   * @testName:         testOthersDeletesAreVisible2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The othersDeletesAreVisible(int resType) method must return a
   *                    boolean value; true if a rows deleted by others are visible and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the otherDeletesAreVisible(int resType) method on that
   *                    object with sql::ResultSet::TYPE_SCROLL_INSENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOthersDeletesAreVisible2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.othersDeletesAreVisible(TYPE_SCROLL_INSENSITIVE)");
    bool retValue=dbmd->othersDeletesAreVisible(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);
    if (retValue) {
      logMsg(
             "Deletes made by others are visible for TYPE_SCROLL_INSENSITIVE");
    } else {
      logMsg(
             "Deletes made by others are not visible for TYPE_SCROLL_INSENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOthersDeletesAreVisible3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The othersDeletesAreVisible(int resType) method must return a
   *                    boolean value; true if a rows deleted by others are visible and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the otherDeletesAreVisible(int resType) method on that
   *                    object with sql::ResultSet::TYPE_SCROLL_SENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOthersDeletesAreVisible3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.othersDeletesAreVisible(TYPE_SCROLL_SENSITIVE)");
    bool retValue=dbmd->othersDeletesAreVisible(sql::ResultSet::TYPE_SCROLL_SENSITIVE);
    if (retValue) {
      logMsg(
             "Deletes made by others are visible for TYPE_SCROLL_SENSITIVE");
    } else {
      logMsg(
             "Deletes made by others are not visible for TYPE_SCROLL_SENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOthersInsertsAreVisible1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The othersInsertsAreVisible(int resType) method must return a
   *                    boolean value; true if a rows inserted by others are visible and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the otherInsertsAreVisible(int resType) method on that
   *                    object with sql::ResultSet::TYPE_FORWARD_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOthersInsertsAreVisible1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.othersInsertsAreVisible(TYPE_FORWARD_ONLY)");
    bool retValue=dbmd->othersInsertsAreVisible(sql::ResultSet::TYPE_FORWARD_ONLY);
    if (retValue) {
      logMsg(
             "Inserts made by others are visible for TYPE_FORWARD_ONLY");
    } else {
      logMsg(
             "Inserts made by others are not visible for TYPE_FORWARD_ONLY");
    }
  
  
  }
  
  /*
   * @testName:         testOthersInsertsAreVisible2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The othersInsertsAreVisible(int resType) method must return a
   *                    boolean value; true if a rows inserted by others are visible and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the otherInsertsAreVisible(int resType) method on that
   *                    object with sql::ResultSet::TYPE_SCROLL_INSENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOthersInsertsAreVisible2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.othersInsertsAreVisible(TYPE_SCROLL_INSENSITIVE)");
    bool retValue=dbmd->othersInsertsAreVisible(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);
    if (retValue) {
      logMsg(
             "Inserts made by others are visible for TYPE_SCROLL_INSENSITIVE");
    } else {
      logMsg(
             "Inserts made by others are not visible for TYPE_SCROLL_INSENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOthersInsertsAreVisible3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The othersInsertsAreVisible(int resType) method must return a
   *                    boolean value; true if a rows inserted by others are visible and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the otherInsertsAreVisible(int resType) method on that
   *                    object with sql::ResultSet::TYPE_SCROLL_SENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOthersInsertsAreVisible3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.othersInsertsAreVisible(TYPE_SCROLL_SENSITIVE)");
    bool retValue=dbmd->othersInsertsAreVisible(sql::ResultSet::TYPE_SCROLL_SENSITIVE);
    if (retValue) {
      logMsg(
             "Inserts made by others are visible for TYPE_SCROLL_SENSITIVE");
    } else {
      logMsg(
             "Inserts made by others are not visible for TYPE_SCROLL_SENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOthersUpdatesAreVisible1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The othersUpdatesAreVisible(int resType) method must return a
   *                    boolean value; true if a rows updated by others are visible and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the otherUpdatesAreVisible(int resType) method on that
   *                    object with sql::ResultSet::TYPE_FORWARD_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOthersUpdatesAreVisible1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.othersUpdatesAreVisible(TYPE_FORWARD_ONLY)");
    bool retValue=dbmd->othersUpdatesAreVisible(sql::ResultSet::TYPE_FORWARD_ONLY);
    if (retValue) {
      logMsg(
             "Updates made by others are visible for TYPE_FORWARD_ONLY");
    } else {
      logMsg(
             "Updates made by others are not visible for TYPE_FORWARD_ONLY");
    }
  
  
  }
  
  /*
   * @testName:         testOthersUpdatesAreVisible2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The othersUpdatesAreVisible(int resType) method must return a
   *                    boolean value; true if a rows updated by others are visible and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the otherUpdatesAreVisible(int resType) method on that
   *                    object with sql::ResultSet::TYPE_SCROLL_INSENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOthersUpdatesAreVisible2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.othersUpdatesAreVisible(TYPE_SCROLL_INSENSITIVE)");
    bool retValue=dbmd->othersUpdatesAreVisible(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);
    if (retValue) {
      logMsg(
             "Updates made by others are visible for TYPE_SCROLL_INSENSITIVE");
    } else {
      logMsg(
             "Updates made by others are not visible for TYPE_SCROLL_INSENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOthersUpdatesAreVisible3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The othersUpdatesAreVisible(int resType) method must return a
   *                    boolean value; true if a rows updated by others are visible and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the otherUpdatesAreVisible(int resType) method on that
   *                    object with sql::ResultSet::TYPE_SCROLL_SENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOthersUpdatesAreVisible3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.othersUpdatesAreVisible(TYPE_SCROLL_SENSITIVE)");
    bool retValue=dbmd->othersUpdatesAreVisible(sql::ResultSet::TYPE_SCROLL_SENSITIVE);
    if (retValue) {
      logMsg(
             "Updates made by others are visible for TYPE_SCROLL_SENSITIVE");
    } else {
      logMsg(
             "Updates made by others are not visible for TYPE_SCROLL_SENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOwnDeletesAreVisible1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The ownDeletesAreVisible(int resType) method must return a
   *                    boolean value; true if a ResultSet object's own deletions are
   *                    visible without having to close and reopen the result set and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the ownDeletesAreVisible(int resType) method on that object
   *                    with sql::ResultSet::TYPE_FORWARD_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOwnDeletesAreVisible1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.ownDeletesAreVisible(TYPE_FORWARD_ONLY)");
    bool retValue=dbmd->ownDeletesAreVisible(sql::ResultSet::TYPE_FORWARD_ONLY);
    if (retValue) {
      logMsg(
             "Result Set's own deletes are visible for TYPE_FORWARD_ONLY");
    } else {
      logMsg(
             "Result Set's own deletes are not visible for TYPE_FORWARD_ONLY");
    }
  
  
  }
  
  /*
   * @testName:         testOwnDeletesAreVisible2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The ownDeletesAreVisible(int resType) method must return a
   *                    boolean value; true if a ResultSet object's own deletions are
   *                    visible without having to close and reopen the result set and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the ownDeletesAreVisible(int resType) method on that object
   *                    with sql::ResultSet::TYPE_SCROLL_INSENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOwnDeletesAreVisible2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.ownDeletesAreVisible(TYPE_SCROLL_INSENSITIVE)");
    bool retValue=dbmd->ownDeletesAreVisible(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);
    if (retValue) {
      logMsg(
             "Result Set's own deletes are visible for TYPE_SCROLL_INSENSITIVE");
    } else {
      logMsg(
             "Result Set's own deletes are not visible for TYPE_SCROLL_INSENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOwnDeletesAreVisible3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The ownDeletesAreVisible(int resType) method must return a
   *                    boolean value; true if a ResultSet object's own deletions are
   *                    visible without having to close and reopen the result set and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the ownDeletesAreVisible(int resType) method on that object
   *                    with sql::ResultSet::TYPE_SCROLL_SENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOwnDeletesAreVisible3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.ownDeletesAreVisible(TYPE_SCROLL_SENSITIVE)");
    bool retValue=dbmd->ownDeletesAreVisible(sql::ResultSet::TYPE_SCROLL_SENSITIVE);
    if (retValue) {
      logMsg(
             "Result Set's own deletes are visible for TYPE_SCROLL_SENSITIVE");
    } else {
      logMsg(
             "Result Set's own deletes are not visible for TYPE_SCROLL_SENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOwnInsertsAreVisible1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The ownInsertsAreVisible(int resType) method must return a
   *                    boolean value; true if a ResultSet object's own insertions are
   *                    visible without having to close and reopen the result set and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the ownInsertsAreVisible(int resType) method on that object
   *                    with sql::ResultSet::TYPE_FORWARD_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOwnInsertsAreVisible1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.ownInsertsAreVisible(TYPE_FORWARD_ONLY)");
    bool retValue=dbmd->ownInsertsAreVisible(sql::ResultSet::TYPE_FORWARD_ONLY);
    if (retValue) {
      logMsg(
             "Result Set's own inserts are visible for TYPE_FORWARD_ONLY");
    } else {
      logMsg(
             "Result Set's own inserts are not visible for TYPE_FORWARD_ONLY");
    }
  
  
  }
  
  /*
   * @testName:         testOwnInsertsAreVisible2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The ownInsertsAreVisible(int resType) method must return a
   *                    boolean value; true if a ResultSet object's own insertions are
   *                    visible without having to close and reopen the result set and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the ownInsertsAreVisible(int resType) method on that object
   *                    with sql::ResultSet::TYPE_SCROLL_INSENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOwnInsertsAreVisible2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.ownInsertsAreVisible(TYPE_SCROLL_INSENSITIVE)");
    bool retValue=dbmd->ownInsertsAreVisible(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);
    if (retValue) {
      logMsg(
             "Result Set's own inserts are visible for TYPE_SCROLL_INSENSITIVE");
    } else {
      logMsg(
             "Result Set's own inserts are not visible for TYPE_SCROLL_INSENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOwnInsertsAreVisible3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The ownInsertsAreVisible(int resType) method must return a
   *                    boolean value; true if a ResultSet object's own insertions are
   *                    visible without having to close and reopen the result set and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the ownInsertsAreVisible(int resType) method on that object
   *                    with sql::ResultSet::TYPE_SCROLL_SENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOwnInsertsAreVisible3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.ownInsertsAreVisible(TYPE_SCROLL_SENSITIVE)");
    bool retValue=dbmd->ownInsertsAreVisible(sql::ResultSet::TYPE_SCROLL_SENSITIVE);
    if (retValue) {
      logMsg(
             "Result Set's own inserts are visible for TYPE_SCROLL_SENSITIVE");
    } else {
      logMsg(
             "Result Set's own inserts are not visible for TYPE_SCROLL_SENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOwnUpdatesAreVisible1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The ownUpdatesAreVisible(int resType) method must return a
   *                    boolean value; true if a ResultSet object's own updates are
   *                    visible without having to close and reopen the result set and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the ownUpdatesAreVisible(int resType) method on that object
   *                    with sql::ResultSet::TYPE_FORWARD_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOwnUpdatesAreVisible1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.ownUpdatesAreVisible(TYPE_FORWARD_ONLY)");
    bool retValue=dbmd->ownUpdatesAreVisible(sql::ResultSet::TYPE_FORWARD_ONLY);
    if (retValue) {
      logMsg(
             "Result Set's own updates are visible for TYPE_FORWARD_ONLY");
    } else {
      logMsg(
             "Result Set's own updates are not visible for TYPE_FORWARD_ONLY");
    }
  
  
  }
  
  /*
   * @testName:         testOwnUpdatesAreVisible2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The ownUpdatesAreVisible(int resType) method must return a
   *                    boolean value; true if a ResultSet object's own updates are
   *                    visible without having to close and reopen the result set and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the ownUpdatesAreVisible(int resType) method on that object
   *                    with sql::ResultSet::TYPE_SCROLL_INSENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOwnUpdatesAreVisible2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.ownUpdatesAreVisible(TYPE_SCROLL_INSENSITIVE)");
    bool retValue=dbmd->ownUpdatesAreVisible(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);
    if (retValue) {
      logMsg(
             "Result Set's own updates are visible for TYPE_SCROLL_INSENSITIVE");
    } else {
      logMsg(
             "Result Set's own updates are not visible for TYPE_SCROLL_INSENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testOwnUpdatesAreVisible3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The ownUpdatesAreVisible(int resType) method must return a
   *                    boolean value; true if a ResultSet object's own updates are
   *                    visible without having to close and reopen the result set and
   *                    false otherwise. The possible values for resType are
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the ownUpdatesAreVisible(int resType) method on that object
   *                    with sql::ResultSet::TYPE_SCROLL_SENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testOwnUpdatesAreVisible3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.ownUpdatesAreVisible(TYPE_SCROLL_SENSITIVE)");
    bool retValue=dbmd->ownUpdatesAreVisible(sql::ResultSet::TYPE_SCROLL_SENSITIVE);
    if (retValue) {
      logMsg(
             "Result Set's own updates are visible for TYPE_SCROLL_SENSITIVE");
    } else {
      logMsg(
             "Result Set's own updates are not visible for TYPE_SCROLL_SENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testStoresLowerCaseIdentifiers
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The storesLowerCaseIdentifiers method must return a boolean
   *                    value; true if DBMS allows mixed case SQL Identifiers in SQL
   *                    statements as case-insensitive and stores them as all lowercases
   *                    in its metadata tables and false otherwise. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the storesLowerCaseIdentifiers() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testStoresLowerCaseIdentifiers()
  {
    logMsg("Calling storesLowerCaseIdentifiers on DatabaseMetaData");
    bool retValue=dbmd->storesLowerCaseIdentifiers();
    if (retValue) {
      logMsg(
             "storesLowerCaseIdentifiers method returns unquoted SQL identifiers stored as lower case");
    } else {
      logMsg(
             "storesLowerCaseIdentifiers returns unquoted SQL identifiers not stored as lower case");
    }
  }
  
  /*
   * @testName:         testStoresLowerCaseQuotedIdentifiers
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The storesLowerCaseQuotedIdentifiers() method must return a boolean
   *                    value; true if DBMS allows mixed case quoted SQL Identifiers
   *                    in SQLstatements as case-insensitive and stores them as all
   *                    lower cases in its metadata tables and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the storesLowerCaseQuotedIdentifiers() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testStoresLowerCaseQuotedIdentifiers()
  {
  
    logMsg(
           "Calling storesLowerCaseQuotedIdentifiers on DatabaseMetaData");
    bool retValue=dbmd->storesLowerCaseQuotedIdentifiers();
    if (retValue) {
      logMsg(
             "storesLowerCaseQuotedIdentifiers method returns SQL identifiers stored as lower case");
    } else {
      logMsg(
             "storesLowerCaseQuotedIdentifiers method returns SQL identifiers not stored as lower case");
    }
  }
  
  /*
   * @testName:         testStoresMixedCaseIdentifiers
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The storesMixedCaseIdentifiers() method must return a boolean
   *                    value; true if DBMS allows mixed case SQL Identifiers in SQL
   *                    statements as case-insensitive and stores them as all mixed cases
   *                    in its metadata tables and false otherwise. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the storesMixedCaseIdentifiers() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testStoresMixedCaseIdentifiers()
  {
  
    logMsg("Calling storesMixedCaseIdentifiers on DatabaseMetaData");
    bool retValue=dbmd->storesMixedCaseIdentifiers();
    if (retValue) {
      logMsg(
             "storesMixedCaseIdentifiers method returns unquoted SQL identifiers stored as mixed case");
    } else {
      logMsg(
             "storesMixedCaseIdentifiers method returns unquoted SQL identifiers not stored as mixed case");
    }
  }
  
  /*
   * @testName:         testStoresMixedCaseQuotedIdentifiers
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The storesMixedCaseQuotedIdentifiers() method must return a boolean
   *                    value; true if DBMS allows mixed case quoted SQL Identifiers in SQL
   *                    statements as case-insensitive and stores them as all mixed cases
   *                    in its metadata tables and false otherwise. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the storesMixedCaseQuotedIdentifiers() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testStoresMixedCaseQuotedIdentifiers()
  {
  
    logMsg(
           "Calling storesMixedCaseQuotedIdentifiers on DatabaseMetaData");
    bool retValue=dbmd->storesMixedCaseQuotedIdentifiers();
    if (retValue) {
      logMsg(
             "storesMixedCaseQuotedIdentifiers method returns SQL identifiers stored as mixed case");
    } else {
      logMsg(
             "storesMixedCaseQuotedIdentifiers method returns SQL identifiers not stored as mixed case");
    }
  }
  
  /*
   * @testName:         testStoresUpperCaseIdentifiers
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The storesUpperCaseIdentifiers method must return a boolean
   *                    value; true if DBMS allows mixed case SQL Identifiers in SQL
   *                    statements as case-insensitive and stores them as all uppercases
   *                    in its metadata tables and false otherwise. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the storesUpperCaseIdentifiers() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testStoresUpperCaseIdentifiers()
  {
  
    logMsg("Calling storesUpperCaseIdentifiers on DatabaseMetaData");
    bool retValue=dbmd->storesUpperCaseIdentifiers();
    if (retValue) {
      logMsg(
             "storesUpperCaseIdentifiers method returns unquoted SQL identifiers stored as upper case");
    } else {
      logMsg(
             "storesUpperCaseIdentifiers method returns unquoted SQL identifiers not stored as upper case");
    }
  
  }
  
  /*
   * @testName:         testStoresUpperCaseQuotedIdentifiers
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The storesUpperCaseQuotedIdentifiers() method must return a boolean
   *                    value; true if DBMS allows mixed case quoted SQL Identifiers in SQL
   *                    statements as case-insensitive and stores them as all upper cases
   *                    in its metadata tables and false otherwise. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the storesUpperCaseQuotedIdentifiers() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testStoresUpperCaseQuotedIdentifiers()
  {
  
    logMsg(
           "Calling storesUpperCaseQuotedIdentifiers on DatabaseMetaData");
    bool retValue=dbmd->storesUpperCaseQuotedIdentifiers();
    if (retValue) {
      logMsg(
             "storesUpperCaseQuotedIdentifiers method returns SQL identifiers stored as upper case");
    } else {
      logMsg(
             "storesUpperCaseQuotedIdentifiers method returns SQL identifiers not stored as upper case");
    }
  }
  
  /*
   * @testName:         testSupportsANSI92EntryLevelSQL
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsANSI92EntryLevelSQL() method must return a boolean
   *                    value; true if the database supports ANSI92 entry level SQL
   *                    grammar and false otherwise.  All JDBC Compliant drivers must
   *                    return true. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsANSI92EntryLevelSQL() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsANSI92EntryLevelSQL()
  {
  
    logMsg("Calling supportsANSI92EntryLevelSQL on DatabaseMetaData");
    bool retValue=dbmd->supportsANSI92EntryLevelSQL();
    if (retValue) {
      logMsg("supportsANSI92EntryLevelSQL method is supported");
    } else {
      logMsg("supportsANSI92EntryLevelSQL method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsANSI92FullSQL
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsANSI92FullSQL() method must return a boolean value
   *                    true if the database supports ANSI92 Full SQL grammar and false
   *                    otherwise.  (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsANSI92FullSQL() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsANSI92FullSQL()
  {
  
    bool retValue=dbmd->supportsANSI92FullSQL();
    logMsg("Calling supportsANSI92FullSQL on DatabaseMetaData");
    if (retValue) {
      logMsg("supportsANSI92FullSQL method is supported");
    } else {
      logMsg("supportsANSI92FullSQL method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsANSI92IntermediateSQL
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsANSI92IntermediateSQL() method must return a boolean
   *                    value; true if the database supports ANSI92 Intermediate SQL
   *                    grammar and false otherwise.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsANSI92IntermediateSQL() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsANSI92IntermediateSQL()
  {
  
    logMsg("Calling supportsANSI92IntermediateSQL on DatabaseMetaData");
    bool retValue=dbmd->supportsANSI92IntermediateSQL();
    if (retValue) {
      logMsg("supportsANSI92IntermediateSQL method is supported");
    } else {
      logMsg("supportsANSI92IntermediateSQL method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsAlterTableWithAddColumn
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsAlterTableWithAddColumn() method must return a
   *                    boolean value; true if the database supports ALTER TABLE
   *                    with add Column and false otherwise (See JDK 1.2.2 API
   *                    documentation).
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsAlterTableWithAddColumn() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsAlterTableWithAddColumn()
  {
  
    logMsg(
           "Calling supportsAlterTableWithAddColumn on DatabaseMetaData");
    bool retValue=dbmd->supportsAlterTableWithAddColumn();
    if (retValue) {
      logMsg("supportsAlterTableWithAddColumn is supported");
    } else {
      logMsg("supportsAlterTableWithAddColumn is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsAlterTableWithDropColumn
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsAlterTableWithDropColumn() method must return a
   *                    boolean value; true if the database supports ALTER TABLE
   *                    with drop column and false otherwise (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsAlterTableWithDropColumn() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsAlterTableWithDropColumn()
  {
  
    logMsg(
           "Calling supportsAlterTableWithDropColumn on DatabaseMetaData");
    bool retValue=dbmd->supportsAlterTableWithDropColumn();
    if (retValue) {
      logMsg("supportsAlterTableWithDropColumn is supported");
    } else {
      logMsg("supportsAlterTableWithDropColumn is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsBatchUpdates
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsBatchUpdates() method must return a boolean
   *                    value; true if the driver supports batch updates and false
   *                    otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsBatchUpdates() method.
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsBatchUpdates()
  {
  
    logMsg("Calling DatabaseMetaData.supportsBatchUpdates");
    bool retValue=dbmd->supportsBatchUpdates();
    if (retValue) {
      logMsg("supportsBatchUpdates is supported");
    } else {
      logMsg("supportsBatchUpdates is not supported");
    }
  
  
  }
  
  /*
   * @testName:         testSupportsCatalogsInDataManipulation
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsCatalogsInDataManipulation() method must return a
   *                    boolean value; true if the database supports using a catalog name
   *                    in a data manipulation statement and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase.
   *                    Call to supportsCatalogsInDataManipulation()on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsCatalogsInDataManipulation()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsCatalogsInDataManipulation");
    bool retValue=dbmd->supportsCatalogsInDataManipulation();
    if (retValue) {
      logMsg("supportsCatalogsInDataManipulation is supported");
    } else {
      logMsg("supportsCatalogsInDataManipulation is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsCatalogsInIndexDefinitions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsCatalogsInIndexDefinitions() method must return a
   *                    boolean value; true if the database supports using a catalog name
   *                    in a index definition statement and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    Call the supportsCatalogsInIndexDefinitions() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsCatalogsInIndexDefinitions()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsCatalogsInIndexDefinitions");
    bool retValue=dbmd->supportsCatalogsInIndexDefinitions();
    if (retValue) {
      logMsg("supportsCatalogsInIndexDefinitions is supported");
    } else {
      logMsg("supportsCatalogsInIndexDefinitions is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsCatalogsInPrivilegeDefinitions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsCatalogsInPrivilegeDefinitions() method must return a
   *                    boolean value; true if the database supports using a catalog name
   *                    in a privilege definition statement and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsCatalogsInPrivilegeDefinitions() method on that
   *                    object. It should return a boolean value; either true or false
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsCatalogsInPrivilegeDefinitions()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsCatalogsInPrivilegeDefinitions");
    bool retValue=dbmd->supportsCatalogsInPrivilegeDefinitions();
    if (retValue) {
      logMsg("supportsCatalogsInPrivilegeDefinitions is supported");
    } else {
      logMsg(
             "supportsCatalogsInPrivilegeDefinitions is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsCatalogsInProcedureCalls
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsCatalogsInProcedureCalls() method must return a
   *                    boolean value; true if the database supports using a catalog name
   *                    in a procedure call statement and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase.
   *                    Call to supportsCatalogsInProcedureCalls() on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsCatalogsInProcedureCalls()
  {
  
    logMsg("Calling DatabaseMetaData.supportsCatalogsInProcedureCalls");
    bool retValue=dbmd->supportsCatalogsInProcedureCalls();
    if (retValue) {
      logMsg("supportsCatalogsInProcedureCalls is supported");
    } else {
      logMsg("supportsCatalogsInProcedureCalls is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsCatalogsInTableDefinitions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsCatalogsInTableDefinitions() method must return a
   *                    boolean value; true if the database supports using a catalog name
   *                    in a table definition statement and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    Call the supportsCatalogsInTableDefinitions() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsCatalogsInTableDefinitions()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsCatalogsInTableDefinitions()");
    bool retValue=dbmd->supportsCatalogsInTableDefinitions();
    if (retValue) {
      logMsg("supportsCatalogsInTableDefinitions is supported");
    } else {
      logMsg("supportsCatalogsInTableDefinitions is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsColumnAliasing
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsColumnAliasing() method must return a
   *                    boolean value; true if the database supports column aliasing
   *                    and false otherwise.  A JDBC compliant driver must always return
   *                    true. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsColumnAliasing() method
   *                    It should return a true value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsColumnAliasing()
  {
  
    logMsg("Calling supportsColumnAliasing on DatabaseMetaData");
    bool retValue=dbmd->supportsColumnAliasing();
    if (retValue) {
      logMsg("supportsColumnAliasing is supported");
    } else {
      logMsg("supportsColumnAliasing is not supported");
      FAIL("supportsColumnAliasing should always return true!");
    }
  }
  
  /*
   * @testName:         testSupportsConvert
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert() method must return a boolean value;
   *                    true if the database supports the scalar function CONVERT for
   *                    for the conversion of one JDBC type to another and false
   *                    otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert()
  {
  
    logMsg("Calling supportsConvert on DatabaseMetaData");
    bool retValue=dbmd->supportsConvert();
    if (retValue) {
      logMsg("supportsConvert method is supported");
    } else {
      logMsg("supportsConvert method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsConvert01
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(ARRAY, VARCHAR) method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert01()
  {
    logMsg(
           "Calling supportsConvert(ARRAY, VARCHAR) on DatabaseMetaData");
  
  #ifdef WE_HAVE_ALL_DATATYPES_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::ARRAY
                                        , sql::DataType::VARCHAR);
  
    if (retValue) {
      logMsg("supportsConvert(ARRAY, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(ARRAY, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(ARRAY, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert02
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(BIGINT, VARCHAR) method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert02()
  {
    logMsg("Calling supportsConvert(BIGINT, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::BIGINT, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(BIGINT, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(BIGINT, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(BIGINT, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert03
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(BINARY, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert03()
  {
  
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::BINARY, sql::DataType::VARCHAR);
    logMsg(
           "Calling supportsConvert(BINARY, VARCHAR) on DatabaseMetaData");
    if (retValue) {
      logMsg("supportsConvert(BINARY, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(BINARY, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(BINARY, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert04
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation).
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(BIT, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert04()
  {
    logMsg("Calling supportsConvert(BIT, VARCHAR) on DatabaseMetaData");
    bool retValue=dbmd->supportsConvert(sql::DataType::BIT, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(BIT, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(BIT, VARCHAR) method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsConvert05
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(BLOB, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert05()
  {
  
    logMsg("Calling supportsConvert(BLOB, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_ALL_DATATYPES_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::BLOB, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(BLOB, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(BLOB, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(BLOB, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert06
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(CHAR, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert06()
  {
  
    logMsg("Calling supportsConvert(CHAR, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::CHAR, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(CHAR, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(CHAR, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(CHAR, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert07
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(CLOB, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert07()
  {
  
    logMsg("Calling supportsConvert(CLOB, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_ALL_DATATYPES_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::CLOB, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(CLOB, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(CLOB, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(CLOB, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert08
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(DATE, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert08()
  {
  
    logMsg("Calling supportsConvert(DATE, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::DATE, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(DATE, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(DATE, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(DATE, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert09
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(DECIMAL, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert09()
  {
  
    logMsg("Calling supportsConvert(DECIMAL, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::DECIMAL, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(DECIMAL, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(DECIMAL, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(DECIMAL, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert10
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(DISTINCT, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert10()
  {
  
    logMsg(
           "Calling supportsConvert(DISTINCT, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_ALL_DATATYPES_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::DISTINCT,
                                        sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(DISTINCT, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(DISTINCT, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(DISTINCT, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert11
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(DOUBLE, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert11()
  {
  
    logMsg(
           "Calling supportsConvert(DOUBLE, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::DOUBLE, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(DOUBLE, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(DOUBLE, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(DOUBLE, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert12
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(FLOAT, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert12()
  {
  
    logMsg(
           "Calling supportsConvert(FLOAT, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_ALL_DATATYPES_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::FLOAT, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(FLOAT, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(FLOAT, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(FLOAT, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert13
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(INTEGER, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert13()
  {
  
    logMsg(
           "Calling supportsConvert(INTEGER, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::INTEGER, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(INTEGER, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(INTEGER, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(INTEGER, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert14
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(JAVA_OBJECT, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* Doesn't make sense in C/C++*/
  /*
    void DatabaseMetaDataTest::testSupportsConvert14() {
  
              logMsg(
                  "Calling supportsConvert(JAVA_OBJECT, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
              bool retValue = dbmd->supportsConvert(sql::DataType::JAVA_OBJECT,
                      sql::DataType::VARCHAR);
              if (retValue) {
                  logMsg(
                      "supportsConvert(JAVA_OBJECT, VARCHAR) method is supported");
              } else {
                  logMsg("supportsConvert(JAVA_OBJECT, VARCHAR) method is not supported");
              }
  #else
                  logMsg("supportsConvert(JAVA_OBJECT, VARCHAR) method is not supported");
  #endif
    }
   */
  
  
  /*
   * @testName:         testSupportsConvert15
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(LONGVARBINARY, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert15()
  {
  
    logMsg(
           "Calling supportsConvert(LONGVARBINARY, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::LONGVARBINARY,
                                        sql::DataType::VARCHAR);
    if (retValue) {
      logMsg(
             "supportsConvert(LONGVARBINARY, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(LONGVARBINARY, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(LONGVARBINARY, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert16
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(LONGVARCHAR, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert16()
  {
  
    logMsg(
           "Calling supportsConvert(LONGVARCHAR, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::LONGVARCHAR,
                                        sql::DataType::VARCHAR);
    if (retValue) {
      logMsg(
             "supportsConvert(LONGVARCHAR, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(LONGVARCHAR, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(LONGVARCHAR, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert17
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(NULL, VARCHAR) on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert17()
  {
    logMsg("Calling supportsConvert(NULL, VARCHAR) on DatabaseMetaData");
  
  
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::SQLNULL, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(NULL, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(NULL, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(NULL, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert18
   * @assertion:        The DatabaseMetaData provides information about the database
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(NUMERIC, VARCHAR) method on that object
   *                    It should return a boolean value; either true or false
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert18()
  {
  
    logMsg(
           "Calling supportsConvert(NUMERIC, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::NUMERIC, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(NUMERIC, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(NUMERIC, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(NUMERIC, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert19
   * @assertion:        The DatabaseMetaData provides information about the database
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(OTHER, VARCHAR) method on that object
   *                    It should return a boolean value; either true or false
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert19()
  {
  
    logMsg(
           "Calling supportsConvert(OTHER, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_ALL_DATATYPES_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::OTHER, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(OTHER, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(OTHER, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(OTHER, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert20
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(REAL, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert20()
  {
  
    logMsg("Calling supportsConvert(REAL, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::REAL, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(REAL, VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(REAL, VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(REAL, VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert21
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(REF, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert21()
  {
  
    logMsg("Calling supportsConvert(REF, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_ALL_DATATYPES_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::REF, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(REF VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(REF VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(REF VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert22
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(SMALLINT, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert22()
  {
  
    logMsg("Calling supportsConvert(SMALLINT, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::SMALLINT,
                                        sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(SMALLINT VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(SMALLINT VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(SMALLINT VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert23
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(STRUCT, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert23()
  {
  
    logMsg("Calling supportsConvert(STRUCT, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_ALL_DATATYPES_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::STRUCT, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(STRUCT VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(STRUCT VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(STRUCT VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert24
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(TIME, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert24()
  {
  
    logMsg("Calling supportsConvert(TIME, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::TIME, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(TIME VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(TIME VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(TIME VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert25
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(TIMESTAMP, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert25()
  {
  
    logMsg("Calling supportsConvert(TIMESTAMP, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::TIMESTAMP,
                                        sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(TIMESTAMP VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(TIMESTAMP VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(TIMESTAMP VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert26
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(TINYINT, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert26()
  {
  
    logMsg("Calling supportsConvert(TINYINT, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::TINYINT, sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(TINYINT VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(TINYINT VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(TINYINT VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert27
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(VARBINARY, VARCHAR) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert27()
  {
  
    logMsg("Calling supportsConvert(VARBINARY, VARCHAR) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::VARBINARY,
                                        sql::DataType::VARCHAR);
    if (retValue) {
      logMsg("supportsConvert(VARBINARY VARCHAR) method is supported");
    } else {
      logMsg("supportsConvert(VARBINARY VARCHAR) method is not supported");
    }
  #else
    logMsg("supportsConvert(VARBINARY VARCHAR) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert28
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(BIGINT, INTEGER) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert28()
  {
  
    logMsg("Calling supportsConvert(BIGINT, INTEGER) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::BIGINT, sql::DataType::INTEGER);
    if (retValue) {
      logMsg("supportsConvert(BIGINT, INTEGER) method is supported");
    } else {
      logMsg("supportsConvert(BIGINT, INTEGER) method is not supported");
    }
  #else
    logMsg("supportsConvert(BIGINT, INTEGER) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert29
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(BIT, INTEGER) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert29()
  {
  
    logMsg("Calling supportsConvert(BIT, INTEGER) on DatabaseMetaData");
  
    bool retValue=dbmd->supportsConvert(sql::DataType::BIT, sql::DataType::INTEGER);
    if (retValue) {
      logMsg("supportsConvert(BIT, INTEGER) method is supported");
    } else {
      logMsg("supportsConvert(BIT, INTEGER) method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsConvert30
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(DATE, INTEGER) method onn that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert30()
  {
  
    logMsg("Calling supportsConvert(DATE, INTEGER) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::DATE, sql::DataType::INTEGER);
    if (retValue) {
      logMsg("supportsConvert(DATE, INTEGER) method is supported");
    } else {
      logMsg("supportsConvert(DATE, INTEGER) method is not supported");
    }
  #else
    logMsg("supportsConvert(DATE, INTEGER) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert31
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(DECIMAL, INTEGER) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert31()
  {
  
    logMsg("Calling supportsConvert(DECIMAL, INTEGER) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::DECIMAL, sql::DataType::INTEGER);
    if (retValue) {
      logMsg("supportsConvert(DECIMAL, INTEGER) method is supported");
    } else {
      logMsg("supportsConvert(DECIMAL, INTEGER) method is not supported");
    }
  #else
    logMsg("supportsConvert(DECIMAL, INTEGER) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert32
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(DOUBLE, INTEGER) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert32()
  {
  
    logMsg("Calling supportsConvert(DOUBLE, INTEGER) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::DOUBLE, sql::DataType::INTEGER);
    if (retValue) {
      logMsg("supportsConvert(DOUBLE, INTEGER) method is supported");
    } else {
      logMsg("supportsConvert(DOUBLE, INTEGER) method is not supported");
    }
  #else
    logMsg("supportsConvert(DOUBLE, INTEGER) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert33
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(FLOAT, INTEGER) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert33()
  {
  
    logMsg("Calling supportsConvert(FLOAT, INTEGER) on DatabaseMetaData");
  #ifdef WE_HAVE_ALL_DATATYPES_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::FLOAT, sql::DataType::INTEGER);
    if (retValue) {
      logMsg("supportsConvert(FLOAT, INTEGER) method is supported");
    } else {
      logMsg("supportsConvert(FLOAT, INTEGER) method is not supported");
    }
  #else
    logMsg("supportsConvert(FLOAT, INTEGER) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert34
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(NUMERIC, INTEGER) method on that object.
   *                    It should return a boolean value; true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert34()
  {
  
    logMsg("Calling supportsConvert(NUMERIC, INTEGER) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::NUMERIC, sql::DataType::INTEGER);
    if (retValue) {
      logMsg("supportsConvert(NUMERIC, INTEGER) method is supported");
    } else {
      logMsg("supportsConvert(NUMERIC, INTEGER) method is not supported");
    }
  #else
    logMsg("supportsConvert(NUMERIC, INTEGER) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert35
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(REAL, INTEGER) method on that object.
   *                    It should return a boolean value; either true false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert35()
  {
  
    logMsg("Calling supportsConvert(REAL, INTEGER) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::REAL, sql::DataType::INTEGER);
    if (retValue) {
      logMsg("supportsConvert(REAL, INTEGER) method is supported");
    } else {
      logMsg("supportsConvert(REAL, INTEGER) method is not supported");
    }
  #else
    logMsg("supportsConvert(REAL, INTEGER) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert36
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(SMALLINT, INTEGER) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert36()
  {
  
    logMsg("Calling supportsConvert(SMALLINT, INTEGER) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::SMALLINT,
                                        sql::DataType::INTEGER);
    if (retValue) {
      logMsg("supportsConvert(SMALLINT, INTEGER) method is supported");
    } else {
      logMsg("supportsConvert(SMALLINT, INTEGER) method is not supported");
    }
  #else
    logMsg("supportsConvert(SMALLINT, INTEGER) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsConvert37
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsConvert(int fromType, int toType) method must return
   *                    a boolean value; true if the database supports the scalar function
   *                    CONVERT for conversions between the JDBC types fromType and toType
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsConvert(TINYINT, INTEGER) method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsConvert37()
  {
  
    logMsg("Calling supportsConvert(TINYINT, INTEGER) on DatabaseMetaData");
  #ifdef WE_HAVE_DATATYPE_AGAIN
    bool retValue=dbmd->supportsConvert(sql::DataType::TINYINT, sql::DataType::INTEGER);
    if (retValue) {
      logMsg("supportsConvert(TINYINT, INTEGER) method is supported");
    } else {
      logMsg("supportsConvert(TINYINT, INTEGER) method is not supported");
    }
  #else
    logMsg("supportsConvert(TINYINT, INTEGER) method is not supported");
  #endif
  }
  
  /*
   * @testName:         testSupportsCoreSQLGrammar
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsCoreSQLGrammar() method must return a boolean value
   *                    true if the database supports the ODBC core SQL grammar and
   *                    false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsCoreSQLGrammar() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsCoreSQLGrammar()
  {
  
    logMsg("Calling supportsCoreSQLGrammar on DatabaseMetaData");
    bool retValue=dbmd->supportsCoreSQLGrammar();
    if (retValue) {
      logMsg("supportsCoreSQLGrammar method is supported");
    } else {
      logMsg("supportsCoreSQLGrammar method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsCorrelatedSubqueries
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsCorrelatedSubqueries() method must return a
   *                    boolean value; true if the database supports correlated subqueries
   *                    and false otherwise. A JDBC Compliant driver always returns true.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsCorrelatedSubqueries() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsCorrelatedSubqueries()
  {
  
    logMsg("Calling DatabaseMetaData.supportsCorrelatedSubqueries");
    bool retValue=dbmd->supportsCorrelatedSubqueries();
    if (retValue) {
      logMsg("supportsCorrelatedSubqueries is supported");
    } else {
      logMsg("supportsCorrelatedSubqueries is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsDataDefinitionAndDataManipulationTransactions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsDataDefinitionAndDataManipulationTransactions method
   *                    must return a boolean value; true if both data definition and
   *                    data manipulation statements within a transaction are supported;
   *                    false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsDataDefinitionAndDataManipulationTransactions() method.
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsDataDefinitionAndDataManipulationTransactions()
  {
    logMsg(
           "Calling DatabaseMetaData.supportsDataDefinitionAndDataManipulationTransactions");
    bool retValue=dbmd->supportsDataDefinitionAndDataManipulationTransactions();
    if (retValue) {
      logMsg(
             "supportsDataDefinitionAndDataManipulationTransactions is supported");
    } else {
      logMsg(
             "supportsDataDefinitionAndDataManipulationTransactions is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsDataManipulationTransactionsOnly
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsDataManipulationTransactionsOnly() method must return
   *                    a boolean value, true if the data manipulation statements within
   *                    a transaction is supported and false otherwise. A JDBC Compliant
   *                    driver should return true. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsDataManipulationTransactionsOnly() method.
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsDataManipulationTransactionsOnly()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsDataManipulationTransactionsOnly");
    bool retValue=dbmd->supportsDataManipulationTransactionsOnly();
    if (retValue) {
      logMsg("supportsDataManipulationTransactionsOnly is supported");
    } else {
      logMsg(
             "supportsDataManipulationTransactionsOnly is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsDifferentTableCorrelationNames
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsDifferentTableCorrelationNames() method must return
   *                    a boolean value; true if the database supports table
   *                    correlation names and false otherwise. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsDifferentTableCorrelationNames() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsDifferentTableCorrelationNames()
  {
  
    logMsg(
           "Calling supportsDifferentTableCorrelationNames on DatabaseMetaData");
    bool retValue=dbmd->supportsDifferentTableCorrelationNames();
    if (retValue) {
      logMsg(
             "supportsDifferentTableCorrelationNames method is supported");
    } else {
      logMsg(
             "supportsDifferentTableCorrelationNames method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsExpressionsInOrderBy
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsExpressionsInOrderBy() method must return
   *                    a boolean value; true if the database supports expressions
   *                    in ORDER BY lists and false otherwise. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsExpressionsInOrderBy() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsExpressionsInOrderBy()
  {
  
    logMsg("Calling supportsExpressionsInOrderBy on DatabaseMetaData");
    bool retValue=dbmd->supportsExpressionsInOrderBy();
    if (retValue) {
      logMsg("supportsExpressionsInOrderBy method is supported");
    } else {
      logMsg("supportsExpressionsInOrderBy method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsExtendedSQLGrammar
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsExtendedSQLGrammar() method must return a boolean
   *                    value; true if the database supports the ODBC Extended SQL
   *                    grammar and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsExtendedSQLGrammar() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsExtendedSQLGrammar()
  {
  
    logMsg("Calling supportsExtendedSQLGrammar on DatabaseMetaData");
    bool retValue=dbmd->supportsExtendedSQLGrammar();
    if (retValue) {
      logMsg("supportsExtendedSQLGrammar method is supported");
    } else {
      logMsg("supportsExtendedSQLGrammar method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsFullOuterJoins
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsFullOuterJoins() method must return a
   *                    boolean value; true if the database supports full nested outer
   *                    joins and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsFullOuterJoins() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsFullOuterJoins()
  {
  
    logMsg("Calling supportsFullOuterJoins on DatabaseMetaData");
    bool retValue=dbmd->supportsFullOuterJoins();
    if (retValue) {
      logMsg("supportsFullOuterJoins method is supported");
      if (!dbmd->supportsLimitedOuterJoins())
      {
        FAIL("supportsLimitedOuterJoins() must "
             + "be true if supportsFullOuterJoins() " + "is true!");
      }
    } else {
      logMsg("supportsFullOuterJoins method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsGroupBy
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsGroupBy() method must return a boolean value;
   *                    true if the database supports GROUP BY clause
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsGroupBy() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsGroupBy()
  {
  
    logMsg("Calling supportsGroupBy on DatabaseMetaData");
    bool retValue=dbmd->supportsGroupBy();
    if (retValue) {
      logMsg("supportsGroupBy method is supported");
    } else {
      logMsg("supportsGroupBy method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsGroupByBeyondSelect
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsGroupByBeyondSelect() method must return a boolean
   *                    value; true if a GROUP BY clause can use columns that are not
   *                    in the SELECT clause. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsGroupByBeyondSelect() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsGroupByBeyondSelect()
  {
  
    logMsg("Calling supportsGroupByBeyondSelect on DatabaseMetaData");
    bool retValue=dbmd->supportsGroupByBeyondSelect();
    if (retValue) {
      logMsg("supportsGroupByBeyondSelect method is supported");
    } else {
      logMsg("supportsGroupByBeyondSelect method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsGroupByUnrelated
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsGroupByUnrelated() method must return a boolean value;
   *                    true if a GROUP BY clause can use columns that are not in the
   *                    SELECT clause and false otherwise (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsGroupByUnrelated() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsGroupByUnrelated()
  {
  
    logMsg("Calling supportsGroupByUnrelated on DatabaseMetaData");
    bool retValue=dbmd->supportsGroupByUnrelated();
    if (retValue) {
      logMsg("supportsGroupByUnrelated method is supported");
    } else {
      logMsg("supportsGroupByUnrelated method is not supported");
    }
  }
  
  
  #ifdef INCLUDE_NOT_IMPLEMENTED_METHODS
  /*
   * @testName:         testSupportsIntegrityEnhancementFacility
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsIntegrityEnhancementFacility() method must return a
   *                    boolean value; true if the database supports the SQL Integrity
   *                    Enhancement Facility and false otherwise.
   *                   (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsIntegrityEnhancementFacility() method onn that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsIntegrityEnhancementFacility()
  {
    logMsg(
           "Calling supportsIntegrityEnhancementFacility on DatabaseMetaData");
    bool retValue=dbmd->supportsIntegrityEnhancementFacility();
    if (retValue) {
      logMsg(
             "supportsIntegrityEnhancementFacility method is supported");
    } else {
      logMsg(
             "supportsIntegrityEnhancementFacility method is not supported");
    }
  }
  #endif
  
  
  /*
   * @testName:         testSupportsLikeEscapeClause
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsLikeEscapeClause() method must return a boolean value
   *                    true if the database supports specifying a LIKE escape clause
   *                    and false otherwise.  A JDBC compliant driver always return true.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsLikeEscapeClause() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsLikeEscapeClause()
  {
    logMsg("Calling supportsLikeEscapeClause on DatabaseMetaData");
    bool retValue=dbmd->supportsLikeEscapeClause();
    if (retValue) {
      logMsg("supportsLikeEscapeClause method is supported");
    } else {
      logMsg("supportsLikeEscapeClause method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsLimitedOuterJoins
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsLimitedOuterJoins() method must return a
   *                    boolean value; true if the database supports limited outer joins
   *                    and false otherwise. Note if the method supportsFullOuterJoins
   *                    return true, this method will return true. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsLimitedOuterJoins() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsLimitedOuterJoins()
  {
    logMsg("Calling supportsLimitedOuterJoins on DatabaseMetaData");
    bool retValue=dbmd->supportsLimitedOuterJoins();
    if (retValue) {
      logMsg("supportsLimitedOuterJoins method is supported");
    } else {
      logMsg("supportsLimitedOuterJoins method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsMinimumSQLGrammar
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsMinimumSQLGrammar() method must return a boolean
   *                    value; true if the database supports the ODBC Minimum SQL
   *                    grammar and false otherwise.  All JDBC Compliant drivers must
   *                    return true. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsMinimumSQLGrammar() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsMinimumSQLGrammar()
  {
    logMsg("Calling supportsMinimumSQLGrammar on DatabaseMetaData");
    bool retValue=dbmd->supportsMinimumSQLGrammar();
    if (retValue) {
      logMsg("supportsMinimumSQLGrammar method is supported");
    } else {
      logMsg("supportsMinimumSQLGrammar method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsMixedCaseIdentifiers
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The supportsMixedCaseIdentifiers method must return a boolean
   *                    value; true if DBMS allows mixed case SQL Identifiers in SQL
   *                    statements as case-sensitive and false otherwise.  A JDBC
   *                    compliant driver will  always return false.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsMixedCaseIdentifiers() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsMixedCaseIdentifiers()
  {
    logMsg("Calling supportsMixedCaseIdentifiers on DatabaseMetaData");
    bool retValue=dbmd->supportsMixedCaseIdentifiers();
    if (retValue) {
      logMsg("supportsMixedCaseIdentifiers method is supported");
    } else {
      logMsg("supportsMixedCaseIdentifiers method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsMixedCaseQuotedIdentifiers
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsMixedCaseQuotedIdentifiers() method must return a boolean
   *                    value; true if DBMS allows mixed case quoted SQL Identifiers in SQL
   *                    statements as case-insensitive and stores them as all mixed cases
   *                    in its metadata tables and false otherwise. A JDBC Compliant
   *                    driver will always return true. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsMixedCaseQuotedIdentifiers() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsMixedCaseQuotedIdentifiers()
  {
  
    logMsg(
           "Calling supportsMixedCaseQuotedIdentifiers on DatabaseMetaData");
    bool retValue=dbmd->supportsMixedCaseQuotedIdentifiers();
    if (retValue) {
      logMsg("supportsMixedCaseQuotedIdentifiers method is supported");
    } else {
      logMsg(
             "supportsMixedCaseQuotedIdentifiers method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsMultipleResultSets
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsMultipleResultSets() method must return a boolean value
   *                    true if the database supports multiple result sets from a single
   *                    execute statement and false otherwise. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsMultipleResultSets() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsMultipleResultSets()
  {
  
    logMsg("Calling supportsMultipleResultSets on DatabaseMetaData");
    bool retValue=dbmd->supportsMultipleResultSets();
    if (retValue) {
      logMsg("supportsMultipleResultSets method is supported");
    } else {
      logMsg("supportsMultipleResultSets method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsMultipleTransactions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsMultipleTransactions() method must return a boolean
   *                    value; true if multiple transactions can be open at once on
   *                    different connections and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsMultipleTransactions() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsMultipleTransactions()
  {
    logMsg("Calling supportsMultipleTransactions on DatabaseMetaData");
    bool retValue=dbmd->supportsMultipleTransactions();
    if (retValue) {
      logMsg("supportsMultipleTransactions method is supported");
    } else {
      logMsg("supportsMultipleTransactions method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsNonNullableColumns
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsNonNullableColumns() method must return a boolean
   *                    value; true if the database supports defining columns as
   *                    non-nullable and false otherwise.  (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsNonNullableColumns() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsNonNullableColumns()
  {
  
    logMsg("Calling supportsNonNullableColumns on DatabaseMetaData");
    bool retValue=dbmd->supportsNonNullableColumns();
    if (retValue) {
      logMsg("supportsNonNullableColumns method is supported");
    } else {
      logMsg("supportsNonNullableColumns method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsOpenCursorsAcrossCommit
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsOpenCursorsAcrossCommit() method must return a boolean
   *                    value; true if cursors always remain open after commits; false
   *                    if cursors are closed on commit. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsOpenCursorsAcrossCommit() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsOpenCursorsAcrossCommit()
  {
  
    logMsg("Calling DatabaseMetaData.supportsOpenCursorsAcrossCommit");
    bool retValue=dbmd->supportsOpenCursorsAcrossCommit();
    if (retValue) {
      logMsg("supportsOpenCursorsAcrossCommit is supported");
    } else {
      logMsg("supportsOpenCursorsAcrossCommit is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsOpenCursorsAcrossRollback
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsOpenCursorsAcrossRollback() method must return a boolean
   *                    value; true if cursors always remain open after rollbacks; false
   *                    if cursors are closed on rollback. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsOpenCursorsAcrossRollback() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsOpenCursorsAcrossRollback()
  {
  
    logMsg("Calling DatabaseMetaData.supportsOpenCursorsAcrossRollback");
    bool retValue=dbmd->supportsOpenCursorsAcrossRollback();
    if (retValue) {
      logMsg("supportsOpenCursorsAcrossRollback is supported");
    } else {
      logMsg("supportsOpenCursorsAcrossRollback is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsOpenStatementsAcrossCommit
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsOpenStatementsAcrossCommit() method must return a
   *                    boolean value; true if statements always remain open after
   *                    commits; false if statements are closed on commit.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsOpenStatementsAcrossCommit() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsOpenStatementsAcrossCommit()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsOpenStatementsAcrossCommit");
    bool retValue=dbmd->supportsOpenStatementsAcrossCommit();
    if (retValue) {
      logMsg("supportsOpenStatementsAcrossCommit is supported");
    } else {
      logMsg("supportsOpenStatementsAcrossCommit is not supported");
    }
  
  
  }
  
  /*
   * @testName:         testSupportsOpenStatementsAcrossRollback
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsOpenStatementsAcrossRollback() method must return a
   *                    boolean value; true if statements always remain open after
   *                    rollbacks; false if statements are closed on rollback.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsOpenStatementsAcrossRollback() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsOpenStatementsAcrossRollback()
  {
    logMsg(
           "Calling DatabaseMetaData.supportsOpenStatementsAcrossRollback");
    bool retValue=dbmd->supportsOpenStatementsAcrossRollback();
    if (retValue) {
      logMsg("supportsOpenStatementsAcrossRollback is supported");
    } else {
      logMsg("supportsOpenStatementsAcrossRollback is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsOrderByUnrelated
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsOrderByUnrelated() method must return
   *                    a boolean value; true if the database supports ORDER BY
   *                    clause can use columns that are not in the SELECT clause
   *                    and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsOrderByUnrelated() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsOrderByUnrelated()
  {
  
    logMsg("Calling supportsOrderByUnrelated on DatabaseMetaData");
    bool retValue=dbmd->supportsOrderByUnrelated();
    if (retValue) {
      logMsg("supportsOrderByUnrelated method is supported");
    } else {
      logMsg("supportsOrderByUnrelated method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsOuterJoins
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsOuterJoins() method must return a
   *                    boolean value; true if the database supports form of outer
   *                    joins and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsOuterJoins() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsOuterJoins()
  {
  
    logMsg("Calling supportsOuterJoins on DatabaseMetaData");
    bool retValue=dbmd->supportsOuterJoins();
    if (retValue) {
      logMsg("supportsOuterJoins method is supported");
    } else {
      logMsg("supportsOuterJoins method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsPositionedDelete
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsPositionedDelete() method must return a
   *                    boolean value; true if the database supports positioned
   *                    DELETE statement and false otherwise.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsPositionedDelete() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsPositionedDelete()
  {
  
    logMsg("Calling DatabaseMetaData.supportsPositionedDelete");
    bool retValue=dbmd->supportsPositionedDelete();
    if (retValue) {
      logMsg("supportsPositionedDelete is supported");
    } else {
      logMsg("supportsPositionedDelete is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsPositionedUpdate
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsPositionedUpdate() method must return a
   *                    boolean value; true if the database supports positioned
   *                    UPDATE statement and false otherwise.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsPositionedUpdate() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsPositionedUpdate()
  {
  
    logMsg("Calling DatabaseMetaData.supportsPositionedUpdate");
    bool retValue=dbmd->supportsPositionedUpdate();
    if (retValue) {
      logMsg("supportsPositionedUpdate is supported");
    } else {
      logMsg("supportsPositionedUpdate is not supported");
    }
  }
  
  
  #ifdef INCLUDE_NOT_IMPLEMENTED_METHODS
  /*
   * @testName:         testSupportsResultSetConcurrency1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsResultSetConcurrency(int rsType, int rsConcur)
   *                    method must return a boolean value where possible values for rsType
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE & TYPE_SCROLL_SENSITIVE
   *                    and values for rsConcur can be CONCUR_READ_ONLY and
   *                    CONCUR_UPDATABLE. The method returns true if the database
   *                    supports the concurrency level rsConcur with the combination
   *                    of rsType and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsResultSetConcurrency(int resType, int rsConcur)
   *                    method on that object with TYPE_FORWARD_ONLY and CONCUR_READ_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsResultSetConcurrency1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsResultSetConcurrency(TYPE_FORWARD_ONLY, CONCUR_READ_ONLY)");
    bool retValue=dbmd->supportsResultSetConcurrency(sql::ResultSet::TYPE_FORWARD_ONLY,
                                                     sql::ResultSet::CONCUR_READ_ONLY);
    if (retValue) {
      logMsg(
             "supportsResultSetConcurrency(TYPE_FORWARD_ONLY, CONCUR_READ_ONLY) is supported");
    } else {
      logMsg(
             "supportsResultSetConcurrency(TYPE_FORWARD_ONLY, CONCUR_READ_ONLY) is not supported");
    }
  }
  
  
  /*
   * @testName:         testSupportsResultSetConcurrency2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsResultSetConcurrency(int rsType, int rsConcur)
   *                    method must return a boolean value where possible values for rsType
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE & TYPE_SCROLL_SENSITIVE
   *                    and values for rsConcur can be CONCUR_READ_ONLY and
   *                    CONCUR_UPDATABLE. The method returns true if the database
   *                    supports the concurrency level rsConcur with the combination
   *                    of rsType and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsResultSetConcurrency(int resType, int rsConcur)
   *                    method on that object with TYPE_FORWARD_ONLY and CONCUR_UPDATABLE.
   *                    It should return a boolean value; either true or false.
   *
   */
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsResultSetConcurrency2()
  {
    logMsg(
           "Calling DatabaseMetaData.supportsResultSetConcurrency(TYPE_FORWARD_ONLY, CONCUR_UPDATABLE)");
    bool retValue=dbmd->supportsResultSetConcurrency(sql::ResultSet::TYPE_FORWARD_ONLY,
                                                     sql::ResultSet::CONCUR_UPDATABLE);
    if (retValue) {
      logMsg(
             "supportsResultSetConcurrency(TYPE_FORWARD_ONLY, CONCUR_UPDATABLE) is supported");
    } else {
      logMsg(
             "supportsResultSetConcurrency(TYPE_FORWARD_ONLY, CONCUR_UPDATABLE) is not supported");
    }
  }
  
  
  /*
   * @testName:         testSupportsResultSetConcurrency3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsResultSetConcurrency(int rsType, int rsConcur)
   *                    method must return a boolean value where possible values for rsType
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE & TYPE_SCROLL_SENSITIVE
   *                    and values for rsConcur can be CONCUR_READ_ONLY and
   *                    CONCUR_UPDATABLE. The method returns true if the database
   *                    supports the concurrency level rsConcur with the combination
   *                    of rsType and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsResultSetConcurrency(int resType, int rsConcur)
   *                    method on that object with TYPE_SCROLL_INSENSITIVE and CONCUR_READ_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsResultSetConcurrency3()
  {
    logMsg(
           "Calling DatabaseMetaData.supportsResultSetConcurrency(TYPE_SCROLL_INSENSITIVE, CONCUR_READ_ONLY)");
    bool retValue=dbmd->supportsResultSetConcurrency(sql::ResultSet::TYPE_SCROLL_INSENSITIVE,
                                                     sql::ResultSet::CONCUR_READ_ONLY);
    if (retValue) {
      logMsg(
             "supportsResultSetConcurrency(TYPE_SCROLL_INSENSITIVE, CONCUR_READ_ONLY) is supported");
    } else {
      logMsg(
             "supportsResultSetConcurrency(TYPE_SCROLL_INSENSITIVE, CONCUR_READ_ONLY) is not supported");
    }
  }
  
  
  /*
   * @testName:         testSupportsResultSetConcurrency4
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsResultSetConcurrency(int rsType, int rsConcur)
   *                    method must return a boolean value where possible values for rsType
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE & TYPE_SCROLL_SENSITIVE
   *                    and values for rsConcur can be CONCUR_READ_ONLY and
   *                    CONCUR_UPDATABLE. The method returns true if the database
   *                    supports the concurrency level rsConcur with the combination
   *                    of rsType and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsResultSetConcurrency(int resType, int rsConcur)
   *                    method on that object with TYPE_SCROLL_INSENSITIVE and CONCUR_UPDATABLE.
   *                    It should return a boolean value; either true or false.
   *
   */
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsResultSetConcurrency4()
  {
    logMsg(
           "Calling DatabaseMetaData.supportsResultSetConcurrency(TYPE_SCROLL_INSENSITIVE, CONCUR_UPDATABLE)");
    bool retValue=dbmd->supportsResultSetConcurrency(sql::ResultSet::TYPE_SCROLL_INSENSITIVE,
                                                     sql::ResultSet::CONCUR_UPDATABLE);
    if (retValue) {
      logMsg(
             "supportsResultSetConcurrency(TYPE_SCROLL_INSENSITIVE, CONCUR_UPDATABLE) is supported");
    } else {
      logMsg(
             "supportsResultSetConcurrency(TYPE_SCROLL_INSENSITIVE, CONCUR_UPDATABLE) is not supported");
    }
  }
  
  
  /*
   * @testName:         testSupportsResultSetConcurrency5
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsResultSetConcurrency(int rsType, int rsConcur)
   *                    method must return a boolean value where possible values for rsType
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE & TYPE_SCROLL_SENSITIVE
   *                    and values for rsConcur can be CONCUR_READ_ONLY and
   *                    CONCUR_UPDATABLE. The method returns true if the database
   *                    supports the concurrency level rsConcur with the combination
   *                    of rsType and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsResultSetConcurrency(int resType, int rsConcur)
   *                    method on that object with TYPE_SCROLL_SENSITIVE and CONCUR_READ_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsResultSetConcurrency5()
  {
    logMsg(
           "Calling DatabaseMetaData.supportsResultSetConcurrency(TYPE_SCROLL_SENSITIVE, CONCUR_READ_ONLY)");
    bool retValue=dbmd->supportsResultSetConcurrency(sql::ResultSet::TYPE_SCROLL_SENSITIVE,
                                                     sql::ResultSet::CONCUR_READ_ONLY);
    if (retValue) {
      logMsg(
             "supportsResultSetConcurrency(TYPE_SCROLL_SENSITIVE, CONCUR_READ_ONLY) is supported");
    } else {
      logMsg(
             "supportsResultSetConcurrency(TYPE_SCROLL_SENSITIVE, CONCUR_READ_ONLY) is not supported");
    }
  }
  
  
  /*
   * @testName:         testSupportsResultSetConcurrency6
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsResultSetConcurrency(int rsType, int rsConcur)
   *                    method must return a boolean value where possible values for rsType
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE & TYPE_SCROLL_SENSITIVE
   *                    and values for rsConcur can be CONCUR_READ_ONLY and
   *                    CONCUR_UPDATABLE. The method returns true if the database
   *                    supports the concurrency level rsConcur with the combination
   *                    of rsType and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsResultSetConcurrency(int resType, int rsConcur)
   *                    method on that object with TYPE_SCROLL_SENSITIVE and CONCUR_UPDATABLE.
   *                    It should return a boolean value; either true or false.
   *
   */
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsResultSetConcurrency6()
  {
    logMsg(
           "Calling DatabaseMetaData.supportsResultSetConcurrency(TYPE_SCROLL_SENSITIVE, CONCUR_UPDATABLE)");
    bool retValue=dbmd->supportsResultSetConcurrency(sql::ResultSet::TYPE_SCROLL_SENSITIVE,
                                                     sql::ResultSet::CONCUR_UPDATABLE);
    if (retValue) {
      logMsg(
             "supportsResultSetConcurrency(TYPE_SCROLL_SENSITIVE, CONCUR_UPDATABLE) is supported");
    } else {
      logMsg(
             "supportsResultSetConcurrency(TYPE_SCROLL_SENSITIVE, CONCUR_UPDATABLE) is not supported");
    }
  }
  #endif
  
  
  /*
   * @testName:         testSupportsResultSetType1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsResultSetType(int resType) method must return a
   *                    boolean value where resType can be any one of the following
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE & TYPE_SCROLL_SENSITIVE.
   *                    The value is true if the database supports the ResultSet type
   *                    resType and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsResultSetType(int resType) method with Type TYPE_FORWARD_ONLY
   *                    on that object.It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsResultSetType1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsResultSetType(TYPE_FORWARD_ONLY)");
    bool retValue=dbmd->supportsResultSetType(sql::ResultSet::TYPE_FORWARD_ONLY);
    if (retValue) {
      logMsg("TYPE_FORWARD_ONLY ResultSetType is supported");
    } else {
      logMsg("TYPE_FORWARD_ONLY ResultSetType is not supported");
    }
  
  
  }
  
  /*
   * @testName:         testSupportsResultSetType2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsResultSetType(int resType) method must return a
   *                    boolean value where resType can be any one of the following
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE & TYPE_SCROLL_SENSITIVE.
   *                    The value is true if the database supports the ResultSet type
   *                    resType and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsResultSetType() method with Type TYPE_SCROLL_INSENSITIVE
   *                    on that object.It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsResultSetType2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsResultSetType(TYPE_SCROLL_INSENSITIVE)");
    bool retValue=dbmd->supportsResultSetType(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);
    if (retValue) {
      logMsg("TYPE_SCROLL_INSENSITIVE ResultSetType is supported");
    } else {
      logMsg("TYPE_SCROLL_INSENSITIVE ResultSetType is not supported");
    }
  
  
  }
  
  /*
   * @testName:         testSupportsResultSetType3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsResultSetType(int resType) method must return a
   *                    boolean value where resType can be any one of the following
   *                    TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE & TYPE_SCROLL_SENSITIVE.
   *                    The value is true if the database supports the ResultSet type
   *                    resType and false otherwise. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsResultSetType() method with Type TYPE_SCROLL_SENSITIVE
   *                    on that object.It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsResultSetType3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsResultSetType(TYPE_SCROLL_SENSITIVE)");
    bool retValue=dbmd->supportsResultSetType(sql::ResultSet::TYPE_SCROLL_SENSITIVE);
    if (retValue) {
      logMsg("TYPE_SCROLL_SENSITIVE ResultSetType is supported");
    } else {
      logMsg("TYPE_SCROLL_SENSITIVE ResultSetType is not supported");
    }
  
  
  }
  
  /*
   * @testName:         testSupportsSchemasInDataManipulation
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsSchemasInDataManipulation() method must return a
   *                    boolean value; true if the database supports using a schema name
   *                    in a data manipulation statement and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase.
   *                    Make a call to DatabaseMetadata.supportsSchemasInDataManipulation() on that object.
   *                    It should return a boolean value either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsSchemasInDataManipulation()
  {
  
    logMsg("Calling DatabaseMetaData.supportsSchemasInDataManipulation");
    bool retValue=dbmd->supportsSchemasInDataManipulation();
    if (retValue) {
      logMsg("supportsSchemasInDataManipulation is supported");
    } else {
      logMsg("supportsSchemasInDataManipulation is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsSchemasInIndexDefinitions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsSchemasInIndexDefinitions() method must return a
   *                    boolean value; true if the database supports using a schema name
   *                    in a index definition statement and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase.
   *                    Call to supportsSchemasInIndexDefinitions() on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsSchemasInIndexDefinitions()
  {
  
    logMsg("Calling DatabaseMetaData.supportsSchemasInIndexDefinitions");
    bool retValue=dbmd->supportsSchemasInIndexDefinitions();
    if (retValue) {
      logMsg("supportsSchemasInIndexDefinitions is supported");
    } else {
      logMsg("supportsSchemasInIndexDefinitions is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsSchemasInPrivilegeDefinitions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsSchemasInPrivilegeDefinitions() method must return a
   *                    boolean value; true if the database supports using a schema name
   *                    in a privilege definition statement and false otherwise.
   *                    (See JDK 1.2.2 API documentation).
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase.
   *                    Call to supportsSchemasInPrivilegeDefinitions() on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsSchemasInPrivilegeDefinitions()
  {
    logMsg(
           "Calling DatabaseMetaData.supportsSchemasInPrivilegeDefinitions");
    bool retValue=dbmd->supportsSchemasInPrivilegeDefinitions();
    if (retValue) {
      logMsg("supportsSchemasInPrivilegeDefinitions is supported");
    } else {
      logMsg("supportsSchemasInPrivilegeDefinitions is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsSchemasInProcedureCalls
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsSchemasInProcedureCalls() method must return a
   *                    boolean value; true if the database supports using a schema name
   *                    in a procedure call statement and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase.
   *                    Make a call to DatabaseMetadata.supportsSchemasInProcedureCalls() on
   *                    that object.  It should return a boolean value; either true or false
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsSchemasInProcedureCalls()
  {
  
    logMsg("Calling DatabaseMetaData.supportsSchemasInProcedureCalls");
    bool retValue=dbmd->supportsSchemasInProcedureCalls();
    if (retValue) {
      logMsg("supportsSchemasInProcedureCalls is supported");
    } else {
      logMsg("supportsSchemasInProcedureCalls is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsSchemasInTableDefinitions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsSchemasInTableDefinitions() method must return a
   *                    boolean value; true if the database supports using a schema name
   *                    in a table definition statement and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase.
   *                    Make a call to DatabaseMetadata.supportsSchemasInTableDefinitions()
   *                    on that object.It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsSchemasInTableDefinitions()
  {
  
    logMsg("Calling DatabaseMetaData.supportsSchemasInTableDefinitions");
    bool retValue=dbmd->supportsSchemasInTableDefinitions();
    if (retValue) {
      logMsg("supportsSchemasInTableDefinitions is supported");
    } else {
      logMsg("supportsSchemasInTableDefinitions is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsSelectForUpdate
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsSelectForUpdate() method must return a
   *                    boolean value; true if the database supports positioned
   *                    UPDATE statement and false otherwise.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsSelectForUpdate() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsSelectForUpdate()
  {
  
    logMsg("Calling DatabaseMetaData.supportsSelectForUpdate");
    bool retValue=dbmd->supportsSelectForUpdate();
    if (retValue) {
      logMsg("supportsSelectForUpdate is supported");
    } else {
      logMsg("supportsSelectForUpdate is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsStoredProcedures
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave
   *                    as specified in the JDBC 1.0 and 2.0 specifications. None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented.(See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The supportsStoredProcedures method must return a boolean value;
   *                    true if the database supports stored procedure calls and false if
   *                    the database does not support it. (See JDK 1.2.2 API
   *                    documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsStoredprocedures() method
   *                    It should return true value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsStoredProcedures()
  {
    if (hasSps) {
  
      logMsg("Calling supportsStoredProcedures on DatabaseMetaData");
      bool retValue=dbmd->supportsStoredProcedures();
      if (retValue)
      {
        logMsg("SupportsStoredProcedures is supported");
      } else {
        logErr("SupportsStoredProcedures is not supported");
        FAIL("supportsStoredProcedures should always return true!");
      }
    }
  }
  
  /*
   * @testName:         testSupportsSubqueriesInComparisons
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsSubqueriesInComparisons() method must return a
   *                    boolean value; true if the database supports subqueries in
   *                    comparison expressions and false otherwise.  A JDBC compliant
   *                    driver always returns true. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsSubqueriesInComparisons() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsSubqueriesInComparisons()
  {
  
    logMsg("Calling DatabaseMetaData.supportsSubqueriesInComparisons");
    bool retValue=dbmd->supportsSubqueriesInComparisons();
    if (retValue) {
      logMsg("supportsSubqueriesInComparisons is supported");
    } else {
      logMsg("supportsSubqueriesInComparisons is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsSubqueriesInExists
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsSubqueriesInExists() method must return a
   *                    boolean value; true if the database supports subqueries in
   *                    EXISTS expressions and false otherwise. A JDBC compliant driver
   *                    always returns true. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsSubqueriesInExists() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsSubqueriesInExists()
  {
  
    logMsg("Calling DatabaseMetaData.supportsSubqueriesInExists");
    bool retValue=dbmd->supportsSubqueriesInExists();
    if (retValue) {
      logMsg("supportsSubqueriesInExists is supported");
    } else {
      logMsg("supportsSubqueriesInExists is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsSubqueriesInIns
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsSubqueriesInIns() method must return a
   *                    boolean value; true if the database supports subqueries in
   *                    "IN" statements and false otherwise.  A JDBC Compliant driver
   *                    always returns true.  (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsSubqueriesInIns() method on that object.
   *                    It should return a boolean value either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsSubqueriesInIns()
  {
  
    logMsg("Calling DatabaseMetaData.supportsSubqueriesInIns");
    bool retValue=dbmd->supportsSubqueriesInIns();
    if (retValue) {
      logMsg("supportsSubqueriesInIns is supported");
    } else {
      logMsg("supportsSubqueriesInIns is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsSubqueriesInQuantifieds
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsSubqueriesInQuantifieds() method must return a
   *                    boolean value; true if the database supports subqueries in
   *                    quantified statement and false otherwise.  A JDBC Compliant driver
   *                    always returns true.  (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsSubqueriesInQuantifieds() method on that object.
   *                    It should return a boolean value either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsSubqueriesInQuantifieds()
  {
    logMsg("Calling DatabaseMetaData.supportsSubqueriesInQuantifieds");
    bool retValue=dbmd->supportsSubqueriesInQuantifieds();
  
    if (retValue) {
      logMsg("supportsSubqueriesInQuantifieds is supported");
    } else {
      logMsg("supportsSubqueriesInQuantifieds is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsTableCorrelationNames
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsTableCorrelationNames() method must return
   *                    a boolean value; true if the database supports table
   *                    correlation names and false otherwise.  A JDBC compliant
   *                    driver always return true. (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the supportsTableCorrelationNames() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsTableCorrelationNames()
  {
  
    logMsg("Calling supportsTableCorrelationNames on DatabaseMetaData");
    bool retValue=dbmd->supportsTableCorrelationNames();
    if (retValue) {
      logMsg("supportsTableCorrelationNames method is supported");
    } else {
      logMsg("supportsTableCorrelationNames method is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsTransactionIsolationLevel1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsTransactionIsolationLevel(int isolevel) method must
   *                    return a boolean value; true if the database supports the given
   *                    Transaction Isolation Level isolevel and false otherwise.  The
   *                    possible values for isolevel can be TRANSACTION_NONE,
   *                    TRANSACTION_READ_COMMITTED, TRANSACTION_READ_UNCOMMITTED,
   *                    TRANSACTION_REPEATABLE_READ and TRANSACTION_SERIALIZABLE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsTransactionIsolationLevel(int isolevel) method
   *                    on that object with the isolation level TRANSACTION_NONE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsTransactionIsolationLevel1()
  {
    logMsg(
           "Calling DatabaseMetaData.supportsTransactionIsolationLevel(sql::TRANSACTION_NONE)");
    bool retValue=dbmd->supportsTransactionIsolationLevel(sql::TRANSACTION_NONE);
    if (retValue) {
      logMsg(
             "supportsTransactionIsolationLevel(sql::TRANSACTION_NONE) is supported");
    } else {
      logMsg(
             "supportsTransactionIsolationLevel(sql::TRANSACTION_NONE) is not supported");
    }
  
  
  }
  
  /*
   * @testName:         testSupportsTransactionIsolationLevel2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsTransactionIsolationLevel(int isolevel) method must
   *                    return a boolean value; true if the database supports the given
   *                    Transaction Isolation Level isolevel and false otherwise.  The
   *                    possible values for isolevel can be TRANSACTION_NONE,
   *                    TRANSACTION_READ_COMMITTED, TRANSACTION_READ_UNCOMMITTED,
   *                    TRANSACTION_REPEATABLE_READ and TRANSACTION_SERIALIZABLE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsTransactionIsolationLevel(int isolevel) method
   *                    on that object with the isolation level TRANSACTION_READ_COMMITTED.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsTransactionIsolationLevel2()
  {
    logMsg(
           "Calling DatabaseMetaData.supportsTransactionIsolationLevel(sql::TRANSACTION_READ_COMMITTED)");
    bool retValue=dbmd->supportsTransactionIsolationLevel(sql::TRANSACTION_READ_COMMITTED);
    if (retValue) {
      logMsg(
             "supportsTransactionIsolationLevel(sql::TRANSACTION_READ_COMMITTED) is supported");
    } else {
      logMsg(
             "supportsTransactionIsolationLevel(sql::TRANSACTION_READ_COMMITTED) is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsTransactionIsolationLevel3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsTransactionIsolationLevel(int isolevel) method must
   *                    return a boolean value; true if the database supports the given
   *                    Transaction Isolation Level isolevel and false otherwise.  The
   *                    possible values for isolevel can be TRANSACTION_NONE,
   *                    TRANSACTION_READ_COMMITTED, TRANSACTION_READ_UNCOMMITTED,
   *                    TRANSACTION_REPEATABLE_READ and TRANSACTION_SERIALIZABLE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsTransactionIsolationLevel(int isolevel) method
   *                    on that object with the isolation level TRANSACTION_READ_UNCOMMITTED.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsTransactionIsolationLevel3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsTransactionIsolationLevel(sql::TRANSACTION_READ_UNCOMMITTED)");
    bool retValue=dbmd->supportsTransactionIsolationLevel(sql::TRANSACTION_READ_UNCOMMITTED);
    if (retValue) {
      logMsg(
             "supportsTransactionIsolationLevel(sql::TRANSACTION_READ_UNCOMMITTED) is supported");
    } else {
      logMsg(
             "supportsTransactionIsolationLevel(sql::TRANSACTION_READ_UNCOMMITTED ) is not supported");
    }
  
  
  }
  
  /*
   * @testName:         testSupportsTransactionIsolationLevel4
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsTransactionIsolationLevel(int isolevel) method must
   *                    return a boolean value; true if the database supports the given
   *                    Transaction Isolation Level isolevel and false otherwise.  The
   *                    possible values for isolevel can be TRANSACTION_NONE,
   *                    TRANSACTION_READ_COMMITTED, TRANSACTION_READ_UNCOMMITTED,
   *                    TRANSACTION_REPEATABLE_READ and TRANSACTION_SERIALIZABLE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsTransactionIsolationLevel(int isolevel) method
   *                    on that object with  isolation level TRANSACTION_REPEATABLE_READ.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsTransactionIsolationLevel4()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsTransactionIsolationLevel(sql::TRANSACTION_REPEATABLE_READ)");
    bool retValue=dbmd->supportsTransactionIsolationLevel(sql::TRANSACTION_REPEATABLE_READ);
    if (retValue) {
      logMsg(
             "supportsTransactionIsolationLevel(sql::TRANSACTION_REPEATABLE_READ) is supported");
    } else {
      logMsg(
             "supportsTransactionIsolationLevel(sql::TRANSACTION_REPEATABLE_READ) is not supported");
    }
  
  
  }
  
  /*
   * @testName:         testSupportsTransactionIsolationLevel5
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsTransactionIsolationLevel(int isolevel) method must
   *                    return a boolean value; true if the database supports the given
   *                    Transaction Isolation Level isolevel and false otherwise.  The
   *                    possible values for isolevel can be TRANSACTION_NONE,
   *                    TRANSACTION_READ_COMMITTED, TRANSACTION_READ_UNCOMMITTED,
   *                    TRANSACTION_REPEATABLE_READ and TRANSACTION_SERIALIZABLE.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsTransactionIsolationLevel(int isolevel) method
   *                    on that object with  isolation level TRANSACTION_SERIALIZABLE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsTransactionIsolationLevel5()
  {
  
    logMsg(
           "Calling DatabaseMetaData.supportsTransactionIsolationLevel(sql::TRANSACTION_SERIALIZABLE)");
    bool retValue=dbmd->supportsTransactionIsolationLevel(sql::TRANSACTION_SERIALIZABLE);
    if (retValue) {
      logMsg(
             "supportsTransactionIsolationLevel(sql::TRANSACTION_SERIALIZABLE) is supported");
    } else {
      logMsg(
             "supportsTransactionIsolationLevel(sql::TRANSACTION_SERIALIZABLE) is not supported");
    }
  
  
  }
  
  /*
   * @testName:         testSupportsTransactions
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsTransactions() method must return a boolean
   *                    value; true if transactions are supported and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsTransactions() method.
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsTransactions()
  {
  
    logMsg("Calling DatabaseMetaData.supportsTransactions");
    bool retValue=dbmd->supportsTransactions();
    if (retValue) {
      logMsg("supportsTransactions is supported");
    } else {
      logMsg("supportsTransactions is not supported");
    }
  
  
  }
  
  /*
   * @testName:         testSupportsUnion
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsUnion() method must return a boolean value;
   *                    true if the database supports SQL Union and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsUnion() method on that object.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsUnion()
  {
  
    logMsg("Calling DatabaseMetaData.supportsUnion");
    bool retValue=dbmd->supportsUnion();
    if (retValue) {
      logMsg("supportsUnion is supported");
    } else {
      logMsg("supportsUnion is not supported");
    }
  }
  
  /*
   * @testName:         testSupportsUnionAll
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The supportsUnionAll() method must return a boolean value
   *                    true if the database supports SQL Union All and false otherwise.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the supportsUnionAll() method on that object.
   *                    It should return a boolean value; eithet true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testSupportsUnionAll()
  {
  
    logMsg("Calling DatabaseMetaData.supportsUnionAll");
    bool retValue=dbmd->supportsUnionAll();
    if (retValue) {
      logMsg("supportsUnionAll is supported");
    } else {
      logMsg("supportsUnionAll is not supported");
    }
  }
  
  /*
   * @testName:         testUpdatesAreDetected1
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The updatesAreDetected(int resType) method must return a
   *                    boolean value; true if the method ResultSet.rowUpdated returns
   *                    true when called on a ResultSet object with a given type that
   *                    contains visible row updates; false if the method
   *                    ResultSet.rowUpdated returns false. The possible values for
   *                    resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
   *                    TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the updatesAreDetected() method on that object with the
   *                    ResultSet Type as sql::ResultSet::TYPE_FORWARD_ONLY.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testUpdatesAreDetected1()
  {
  
    logMsg(
           "Calling DatabaseMetaData.updatesAreDetected(TYPE_FORWARD_ONLY)");
    bool retValue=dbmd->updatesAreDetected(sql::ResultSet::TYPE_FORWARD_ONLY);
    if (retValue) {
      logMsg(
             "Visible row update can be detected for TYPE_FORWARD_ONLY");
    } else {
      logMsg(
             "Visible row update cannot be detected for TYPE_FORWARD_ONLY");
    }
  
  
  }
  
  /*
   * @testName:         testUpdatesAreDetected2
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The updatesAreDetected(int resType) method must return a
   *                    boolean value; true if the method ResultSet.rowUpdated returns
   *                    true when called on a ResultSet object with a given type that
   *                    contains visible row updates; false if the method
   *                    ResultSet.rowUpdated returns false. The possible values for
   *                    resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
   *                    TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the updatesAreDetected() method on that object with the
   *                    ResultSet Type as sql::ResultSet::TYPE_SCROLL_INSENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testUpdatesAreDetected2()
  {
  
    logMsg(
           "Calling DatabaseMetaData.updatesAreDetected(TYPE_SCROLL_INSENSITIVE)");
    bool retValue=dbmd->updatesAreDetected(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);
    if (retValue) {
      logMsg(
             "Visible row update can be detected for TYPE_SCROLL_INSENSITIVE");
    } else {
      logMsg(
             "Visible row update cannot be detected for TYPE_SCROLL_INSENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testUpdatesAreDetected3
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *                    The updatesAreDetected(int resType) method must return a
   *                    boolean value; true if the method ResultSet.rowUpdated returns
   *                    true when called on a ResultSet object with a given type that
   *                    contains visible row updates; false if the method
   *                    ResultSet.rowUpdated returns false. The possible values for
   *                    resType are TYPE_FORWARD_ONLY, TYPE_SCROLL_SENSITIVE and
   *                    TYPE_SCROLL_INSENSITIVE.(See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get a DatabaseMetadata object from the connection to the database
   *                    and call the updatesAreDetected() method on that object with the
   *                    ResultSet Type as sql::ResultSet::TYPE_SCROLL_SENSITIVE.
   *                    It should return a boolean value; either true or false.
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testUpdatesAreDetected3()
  {
  
    logMsg(
           "Calling DatabaseMetaData.updatesAreDetected(TYPE_SCROLL_SENSITIVE)");
    bool retValue=dbmd->updatesAreDetected(sql::ResultSet::TYPE_SCROLL_SENSITIVE);
    if (retValue) {
      logMsg(
             "Visible row update can be detected for TYPE_SCROLL_SENSITIVE");
    } else {
      logMsg(
             "Visible row update cannot be detected for TYPE_SCROLL_SENSITIVE");
    }
  
  
  }
  
  /*
   * @testName:         testUsesLocalFilePerTable
   * @assertion:        The DatabaseMetaData provides information about the database.
   *                    (See section 15.1 of JDBC 2.0 API Reference & Tutorial 2nd edition)
   *
   *                    A  driver must provide full support for DatabaseMetaData and
   *                    ResultSetMetaData.  This implies that all of the methods in the
   *                    DatabaseMetaData interface must be implemented and must behave as
   *                    specified in the JDBC 1.0 and 2.0 specifications.  None of the
   *                    methods in DatabaseMetaData and ResultSetMetaData may throw an
   *                    exception because they are not implemented. (See section 6.2.2.3
   *                    of Java2 Platform Enterprise Edition (J2EE) Specification v1.2)
   *
   *                    The usesLocalFilePerTable method must return a boolean value;
   *                    true if the database uses a local file for each table.
   *                    (See JDK 1.2.2 API documentation)
   *
   * @test_Strategy:    Get the DataBaseMetaData object from the Connection to the DataBase
   *                    and call the usesLocalFilePerTable() method
   *                    It should return a boolean value
   *
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::testUsesLocalFilePerTable()
  {
    logMsg("Calling usesLocalFilePerTable on DatabaseMetaData");
    bool retValue=dbmd->usesLocalFilePerTable();
    if (retValue) {
      logMsg(
             "usesLocalFilePerTable method returns database uses a local file");
    } else {
      logMsg(
             "usesLocalFilePerTable method returns database not uses a local file");
    }
  }
  
  /**
   * @see junit.framework.TestCase#setUp()
   */
  
  /* throws Exception */
  void DatabaseMetaDataTest::setUp()
  {
    super::setUp();
  
    sPtable="CTSTABLE1";
  
    Properties::const_iterator cit=sqlProps.find("ptable");
  
    if (cit != sqlProps.end())
      sPtable=cit->second;
  
    sFtable="CTSTABLE2";
  
    cit=sqlProps.find("ftable");
  
    if (cit != sqlProps.end())
      sFtable=cit->second;
  
    if (sPtable.length() == 0) {
      FAIL("Invalid Primary table");
    }
    if (sFtable.length() == 0) {
      FAIL("Invalid Foreign table");
    }
    sSchemaName="";
    dbmd= conn->getMetaData();
  }
  
  /* A private method to compare the Column Names & No of Columns Specific to the test */
  
  /* throws SQLException */
  bool DatabaseMetaDataTest::columnCompare(List & sColumnNames, ResultSet & rset)
  {
    bool test_status=       false;
    bool statusColumnCount= true;
    bool statusColumnMatch= true;
    int iColumnNamesLength= static_cast<int>(sColumnNames.size());
  
    ResultSetMetaData rsmd(rset->getMetaData());
  
    int iCount=rsmd->getColumnCount();
  
    TestsListener::messagesLog() << "Minimum Column Count is:"
            << iColumnNamesLength << std::endl;
  
    if (iColumnNamesLength <= iCount) {
      iCount=iColumnNamesLength;
      statusColumnCount=true;
      logMsg("Different numbers of columns");
    } else {
      statusColumnCount=false;
    }
  
    logMsg("Comparing Column Names...");
  
    while (iColumnNamesLength > 0) {
      if (ciString(sColumnNames[iColumnNamesLength - 1].c_str()) ==
          rsmd->getColumnName(iCount).c_str())
      {
        statusColumnMatch=true;
      } else {
        statusColumnMatch=false;
        logMsg("Wrong column value, dumping expected and returned data");
        logMsg(sColumnNames[iColumnNamesLength - 1]);
        logMsg(rsmd->getColumnName(iCount));
        break;
      }
  
      iCount--;
      iColumnNamesLength--;
    }
  
    if ((statusColumnCount == true) && (statusColumnMatch == true)) {
      test_status=true;
    }
  
    return test_status;
  }
  
  } // namespace compliance
  } // namespace testsuite
  