/**
* 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);
}
