/**
   * run the test
   *
   * @exception T_Fail Unexpected behaviour from the API
   */
  protected void runTestSet() throws T_Fail {

    // get a utility helper

    ContextManager cm1 = contextService.newContextManager();
    contextService.setCurrentContextManager(cm1);

    try {

      // boundry case: 1 row, 13 columns, string types
      SF001(1, 13, T_RowSource.STRING_ROW_TYPE, false);

      // boundry case: 1 rows, 1 null column, string types
      SF001(1, 1, T_RowSource.STRING_ROW_TYPE, false);

      // boundry case: 1000 rows, 1 null column, string types
      SF001(1000, 1, T_RowSource.STRING_ROW_TYPE, false);

      // boundry case: 1000 rows, 2 column (first null, second not null), string types
      SF001(1000, 2, T_RowSource.STRING_ROW_TYPE, false);

      // boundry case: 500 rows, 9 columns (first & last column null), string types
      SF001(500, 9, T_RowSource.STRING_ROW_TYPE, false);

      // 500 rows, 13 column, string type
      SF001(500, 13, T_RowSource.STRING_ROW_TYPE, false);

      // test error condition
      SF001(1000, 2, T_RowSource.STRING_ROW_TYPE, true);

      // The following test tests externalizable types, but we currently don't support it.
      // do, don't run the test yet.
      // 100 rows, 5 column, Integer object type
      // SF001(100, 5, T_RowSource.INTEGER_ROW_TYPE, false);
      // 100 rows, 1 column, Integer object type
      // SF001(100, 1, T_RowSource.INTEGER_ROW_TYPE, false);

      // SF002() tests are used to check performance of the stream file.
      // no need to run them regularly.
      // SF002(0);
      // SF002(1);

    } catch (StandardException se) {

      cm1.cleanupOnError(se);
      throw T_Fail.exceptionFail(se);
    } finally {
      contextService.resetCurrentContextManager(cm1);
    }
  }
  /*
   * create a container that all threads can use
   */
  private long commonContainer() throws T_Fail {

    ContextManager cm1 = contextService.newContextManager();
    contextService.setCurrentContextManager(cm1);
    long cid;

    try {
      Transaction t = t_util.t_startTransaction();
      cid = t_util.t_addContainer(t, 0);
      t_util.t_commit(t);
      t.close();
    } catch (StandardException se) {

      cm1.cleanupOnError(se);
      throw T_Fail.exceptionFail(se);
    } finally {
      contextService.resetCurrentContextManager(cm1);
    }
    return cid;
  }
  /**
   * Run the tests
   *
   * @exception T_Fail Unexpected behaviour from the API
   */
  protected void setupTest() throws T_Fail {
    String rollbackOff = PropertyUtil.getSystemProperty(TEST_ROLLBACK_OFF);
    testRollback = !Boolean.valueOf(rollbackOff).booleanValue();

    // don't automatic boot this service if it gets left around
    if (startParams == null) {
      startParams = new Properties();
    }

    startParams.put(Property.NO_AUTO_BOOT, Boolean.TRUE.toString());
    // remove the service directory to ensure a clean run
    startParams.put(Property.DELETE_ON_CREATE, Boolean.TRUE.toString());

    // see if we are testing encryption
    startParams = T_Util.setEncryptionParam(startParams);

    try {
      factory =
          (RawStoreFactory)
              Monitor.createPersistentService(
                  getModuleToTestProtocolName(), testService, startParams);
      if (factory == null) {
        throw T_Fail.testFailMsg(getModuleToTestProtocolName() + " service not started.");
      }

      lf = factory.getLockFactory();
      if (lf == null) {
        throw T_Fail.testFailMsg("LockFactory.MODULE not found");
      }
    } catch (StandardException mse) {
      throw T_Fail.exceptionFail(mse);
    }

    t_util = new T_Util(factory, lf, contextService);
    commonContainer = commonContainer();

    return;
  }
  // this test test the rowSource over head.
  // when param set to 1, also gets the overhead for writeExternal for Storables
  protected void SF002(int param) throws StandardException, T_Fail {

    T_RowSource rowSource = new T_RowSource(500000, 13, 2, false, null);

    DynamicByteArrayOutputStream out = new DynamicByteArrayOutputStream(16384);
    FormatIdOutputStream logicalDataOut = new FormatIdOutputStream(out);

    long startms = System.currentTimeMillis();
    System.out.println("starting rowSource test, time: " + startms);
    try {

      FormatableBitSet validColumns = rowSource.getValidColumns();

      int numberFields = 0;
      if (validColumns != null) {
        for (int i = validColumns.getLength() - 1; i >= 0; i--) {
          if (validColumns.get(i)) {
            numberFields = i + 1;
            break;
          }
        }
      }

      DataValueDescriptor[] row = rowSource.getNextRowFromRowSource().getRowArray();
      while (row != null) {
        if (SanityManager.DEBUG) {
          SanityManager.ASSERT(row != null, "RowSource returned null");
        }

        int arrayPosition = -1;
        for (int i = 0; i < numberFields; i++) {
          // write each column out
          if (validColumns.get(i)) {
            arrayPosition++;
            DataValueDescriptor column = row[arrayPosition];

            if (param == 1) {
              try {
                Storable sColumn = (Storable) column;
                if (!sColumn.isNull()) {
                  sColumn.writeExternal(logicalDataOut);
                  out.reset();
                }
              } catch (IOException ioe) {
                throw T_Fail.exceptionFail(ioe);
              }
            }
          }
        }

        row = rowSource.getNextRowFromRowSource().getRowArray();
      }

    } finally {

    }

    long endms = System.currentTimeMillis();
    long time2 = endms - startms;
    if (param != 1)
      System.out.println("ended rowSource test, time: " + endms + ", time spent = " + time2);
    else
      System.out.println(
          "------ writeExternal called....\n ended rowSource test, time: "
              + endms
              + ", time spent = "
              + time2);

    PASS("SF002");
  }