/**
   * T_MultiThreadedIteration method
   *
   * @exception T_Fail Unexpected behaviour from the API
   */
  protected void joinSetupTest() throws T_Fail {

    T_Fail.T_ASSERT(factory != null, "raw store factory not setup ");
    T_Fail.T_ASSERT(contextService != null, "Context service not setup ");
    T_Fail.T_ASSERT(commonContainer != -1, "common container not setup ");

    t_util = new T_Util(factory, lf, contextService);
  }
  /**
   * 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;
  }
  /**
   * 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;
  }
  // 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");
  }
  /*
   * create a stream container load with rowCount number of rows.
   * fetch it all back, and check to make sure all rows are correct.
   */
  protected void SF001(int rowCount, int columnCount, int columnType, boolean forceAbort)
      throws StandardException, T_Fail {

    Transaction t = t_util.t_startTransaction();

    int segmentId = StreamContainerHandle.TEMPORARY_SEGMENT;
    Properties properties = new Properties();
    properties.put(RawStoreFactory.STREAM_FILE_BUFFER_SIZE_PARAMETER, "16384");

    // create row source
    T_RowSource testRowSource = null;
    if (forceAbort)
      testRowSource = new T_RowSource(rowCount, columnCount, columnType, forceAbort, t);
    else testRowSource = new T_RowSource(rowCount, columnCount, columnType, forceAbort, null);

    long startms = System.currentTimeMillis();

    long containerId = t.addAndLoadStreamContainer(segmentId, properties, testRowSource, null);

    long endms = System.currentTimeMillis();
    long time = endms - startms;
    REPORT("SF001 - write: " + time + "ms");

    // open the container, and start fetching...
    StreamContainerHandle scHandle = t.openStreamContainer(segmentId, containerId, false);

    // set up the template row
    DataValueDescriptor template[] = null;
    template = testRowSource.getTemplate();

    DataValueDescriptor readRow[] = null;
    readRow = testRowSource.getTemplate();
    segmentId = StreamContainerHandle.TEMPORARY_SEGMENT;
    int fetchCount = 0;
    startms = System.currentTimeMillis();
    ValueRow vReadRow = new ValueRow(readRow.length);
    while (scHandle.fetchNext(vReadRow)) {
      fetchCount++;
      // check to make sure the row is what we inserted.
      // this depends on T_RowSource generate identical rows.
      if (!vReadRow.toString().equals(template.toString()))
        throw T_Fail.testFailMsg(
            "Record's value incorrect, expected :"
                + template.toString()
                + ": - got :"
                + vReadRow.toString());
    }
    endms = System.currentTimeMillis();
    time = endms - startms;
    // check to make sure we got the right number of rows.
    if (fetchCount != rowCount)
      throw T_Fail.testFailMsg(
          "incorrect number of row fetched.  Expecting "
              + rowCount
              + " rows, got "
              + fetchCount
              + ", rows instead.");
    REPORT("SF001 - fetch: " + time + "ms");

    scHandle.close();

    t_util.t_commit(t);
    t.close();

    PASS(
        "SF001, rowCount = "
            + rowCount
            + ", columnCount = "
            + columnCount
            + ", clumn type: "
            + columnType);
  }