int main()
{
// Create the IO for this program, that's WHERE YOU PUT YOUR NAME, please change it.
io::create("Yuancheng Zhang");
// Initialize timer
timer::initTimer();
// Create a timer objects
timer t1;
// start timer
t1.tic();
for (int i = 0; i < 5000000; i++)
{
StressTest();
}
// stop timer
t1.toc();
// log the time for the implicit creation
fprintf(io::getHandle(),"Release Mode\n");
fprintf(io::getHandle(),"Run _with__ RVO: %f ms\n", t1.timeInSeconds()* 1000.0f );
return(0);
}
void MathStressTest()
{
// Create a timer objects
timer t1;
// start timer
t1.tic();
for (int i = 0; i < 5000000; i++)
{
StressTest();
}
// stop timer
t1.toc();
fprintf(io::getHandle()," -----------Math Test------------\n\n");
fprintf(io::getHandle(),"Math test: %f ms\n", t1.timeInSeconds()* 1000.0f );
}
int ModeReqRun(Client *client)
{
int retval = 0;
/* This exits if we don't see a CPU we want,
Also saves us from floating point exceptions on GPU clients
*/
if ((modereq.reqbits & MODEREQ_NEEDS_CPU_MASK) != 0)
{
if (GetNumberOfDetectedProcessors() == 0) // -1 is OK when OS doesn't support detection
return 0;
}
if (++modereq.isrunning == 1)
{
int restart = ((modereq.reqbits & MODEREQ_RESTART) != 0);
modereq.reqbits &= ~MODEREQ_RESTART;
while ((modereq.reqbits & MODEREQ_ALL)!=0)
{
unsigned int bits = modereq.reqbits;
if ((bits & (MODEREQ_BENCHMARK |
MODEREQ_BENCHMARK_QUICK |
MODEREQ_BENCHMARK_ALLCORE )) != 0)
{
do
{
unsigned int contest, benchsecs = 16;
unsigned long sel_contests = modereq.bench_projbits;
modereq.bench_projbits = 0;
if ((bits & (MODEREQ_BENCHMARK_QUICK))!=0)
benchsecs = 8;
for (contest = 0; contest < CONTEST_COUNT; contest++)
{
if (CheckExitRequestTriggerNoIO())
break;
if (sel_contests == 0 /*none set==all set*/
|| (sel_contests & (1L<<contest)) != 0)
{
if ((bits & (MODEREQ_BENCHMARK_ALLCORE))!=0)
if(client->corenumtotestbench < 0)
selcoreBenchmark( client, contest, benchsecs, -1 );
else
selcoreBenchmark( client, contest, benchsecs, client->corenumtotestbench);
else
TBenchmark( client, contest, benchsecs, 0, NULL, NULL );
}
}
Log("Compare and share your rates in the speeds database at\n"
"http://www.distributed.net/speed/\n"
"(benchmark rates are for a single processor core)\n");
} while (!CheckExitRequestTriggerNoIO() && modereq.bench_projbits);
retval |= (bits & (MODEREQ_BENCHMARK_QUICK | MODEREQ_BENCHMARK |
MODEREQ_BENCHMARK_ALLCORE));
modereq.reqbits &= ~(MODEREQ_BENCHMARK_QUICK | MODEREQ_BENCHMARK |
MODEREQ_BENCHMARK_ALLCORE);
}
if ((bits & MODEREQ_CMDLINE_HELP) != 0)
{
DisplayHelp(modereq.helpoption);
modereq.helpoption = (const char *)0;
modereq.reqbits &= ~(MODEREQ_CMDLINE_HELP);
retval |= (MODEREQ_CMDLINE_HELP);
}
if ((bits & (MODEREQ_CONFIG | MODEREQ_CONFRESTART)) != 0)
{
/* cmdline_config is set if there is an explicit --config on the cmdline */
/* Configure() returns <0=error,0=exit+nosave,>0=exit+save */
Configure(client,(!(!modereq.cmdline_config)) /* nottycheck */);
/* it used to be such that restart would only be posted on an exit+save */
/* but now we restart for other retvals too, otherwise the GUI windows */
/* end up with half-assed content */
if ((bits & MODEREQ_CONFRESTART) != 0)
restart = 1;
modereq.cmdline_config = 0;
modereq.reqbits &= ~(MODEREQ_CONFIG | MODEREQ_CONFRESTART);
retval |= (bits & (MODEREQ_CONFIG | MODEREQ_CONFRESTART));
}
if ((bits & (MODEREQ_FETCH | MODEREQ_FLUSH)) != 0)
{
if (client)
{
int domode = 0;
int interactive = ((bits & MODEREQ_FQUIET) == 0);
domode = ((bits & MODEREQ_FETCH) ? BUFFERUPDATE_FETCH : 0);
domode |= ((bits & MODEREQ_FLUSH) ? BUFFERUPDATE_FLUSH : 0);
TRACE_BUFFUPD((0, "BufferUpdate: reason = ModeReqRun\n"));
domode = BufferUpdate( client, domode, interactive );
if (domode & BUFFERUPDATE_FETCH)
retval |= MODEREQ_FETCH;
if (domode & BUFFERUPDATE_FLUSH)
retval |= MODEREQ_FLUSH;
if (domode!=0 && (bits & MODEREQ_FQUIET) != 0)
retval |= MODEREQ_FQUIET;
}
modereq.reqbits &= ~(MODEREQ_FETCH | MODEREQ_FLUSH | MODEREQ_FQUIET);
}
if ((bits & MODEREQ_IDENT) != 0)
{
CliIdentifyModules();
modereq.reqbits &= ~(MODEREQ_IDENT);
retval |= (MODEREQ_IDENT);
}
if ((bits & MODEREQ_UNLOCK) != 0)
{
if (modereq.filetounlock)
{
UnlockBuffer(modereq.filetounlock);
modereq.filetounlock = (const char *)0;
}
modereq.reqbits &= ~(MODEREQ_UNLOCK);
retval |= (MODEREQ_UNLOCK);
}
if ((bits & MODEREQ_IMPORT) != 0)
{
if (modereq.filetoimport && client)
{
BufferImportFileRecords(client, modereq.filetoimport, 1 /* interactive */);
modereq.filetoimport = (const char *)0;
retval |= (MODEREQ_IMPORT);
}
modereq.reqbits &= ~(MODEREQ_IMPORT);
}
if ((bits & MODEREQ_CPUINFO) != 0)
{
DisplayProcessorInformation();
modereq.reqbits &= ~(MODEREQ_CPUINFO);
retval |= (MODEREQ_CPUINFO);
}
if ((bits & (MODEREQ_TEST | MODEREQ_TEST_ALLCORE)) != 0)
{
int testfailed = 0;
do
{
unsigned int contest;
unsigned long sel_contests = modereq.test_projbits;
modereq.test_projbits = 0;
for (contest = 0; !testfailed && contest < CONTEST_COUNT; contest++)
{
if (CheckExitRequestTriggerNoIO())
{
testfailed = 1;
break;
}
if (sel_contests == 0 /*none set==all set*/
|| (sel_contests & (1L<<contest)) != 0)
{
if ((bits & (MODEREQ_TEST_ALLCORE)) != 0)
{
if (client->corenumtotestbench < 0)
{
if (selcoreSelfTest( client, contest, -1 ) < 0)
testfailed = 1;
}
else
{
if (selcoreSelfTest( client, contest, client->corenumtotestbench ) < 0)
testfailed = 1;
}
}
else if ( SelfTest( client, contest ) < 0 )
testfailed = 1;
}
}
} while (!testfailed && modereq.test_projbits);
retval |= (MODEREQ_TEST|MODEREQ_TEST_ALLCORE);
modereq.reqbits &= ~(MODEREQ_TEST|MODEREQ_TEST_ALLCORE);
}
if ((bits & (MODEREQ_STRESS | MODEREQ_STRESS_ALLCORE)) != 0)
{
int testfailed = 0;
do
{
unsigned int contest;
unsigned long sel_contests = modereq.stress_projbits;
modereq.stress_projbits = 0;
for (contest = 0; !testfailed && contest < CONTEST_COUNT; contest++)
{
if (CheckExitRequestTriggerNoIO())
{
testfailed = 1;
break;
}
if (sel_contests == 0 /*none set==all set*/
|| (sel_contests & (1L<<contest)) != 0)
{
if ((bits & (MODEREQ_STRESS_ALLCORE)) != 0)
{
if (client->corenumtotestbench < 0)
{
if (selcoreStressTest( client, contest, -1 ) < 0)
testfailed = 1;
}
else
{
if (selcoreStressTest( client, contest, client->corenumtotestbench ) < 0)
testfailed = 1;
}
}
else if ( StressTest( client, contest ) < 0 )
testfailed = 1;
}
}
} while (!testfailed && modereq.stress_projbits);
retval |= (MODEREQ_STRESS|MODEREQ_STRESS_ALLCORE);
modereq.reqbits &= ~(MODEREQ_STRESS|MODEREQ_STRESS_ALLCORE);
}
if ((bits & MODEREQ_VERSION) != 0)
{
/* the requested information already has been printed */
modereq.reqbits &= ~(MODEREQ_VERSION);
retval |= (MODEREQ_VERSION);
}
if (CheckExitRequestTriggerNoIO())
{
restart = 0;
break;
}
} //end while
if (restart)
RaiseRestartRequestTrigger();
} //if (++isrunning == 1)
modereq.isrunning--;
return retval;
}
static long __bench_or_test( Client *client, int which,
unsigned int cont_i, unsigned int benchsecs, int in_corenum )
{
long rc = -1;
/* FIXME: without -devicenum, test/bench will be run on GPU 0 only */
int device = hackGetUsedDeviceIndex(client, 0);
if (selcore_initlev > 0 /* core table is initialized? */
&& cont_i < CONTEST_COUNT) /* valid contest id? */
{
/* save current state */
int user_cputype = selcorestatics.user_cputype[cont_i];
int corenum = selcorestatics.corenum[cont_i];
int coreidx, corecount = corecount_for_contest( cont_i );
int fastest = -1;
int hardcoded = selcoreGetPreselectedCoreForProject(cont_i, device);
u32 bestrate_hi = 0, bestrate_lo = 0, refrate_hi = 0, refrate_lo = 0;
rc = 0; /* assume nothing done */
for (coreidx = 0; coreidx < corecount; coreidx++)
{
/* only bench/test cores that won't be automatically substituted */
if (apply_selcore_substitution_rules(cont_i, coreidx, device) == coreidx)
{
if (in_corenum < 0)
selcorestatics.user_cputype[cont_i] = coreidx; /* as if user set it */
else
{
if( in_corenum < corecount )
{
selcorestatics.user_cputype[cont_i] = in_corenum;
coreidx = corecount;
}
else /* invalid core selection, test them all */
{
selcorestatics.user_cputype[cont_i] = coreidx;
in_corenum = -1;
}
}
selcorestatics.corenum[cont_i] = -1; /* reset to show name */
if (which == 't') /* selftest */
rc = SelfTest( client, cont_i );
else if (which == 's') /* stresstest */
rc = StressTest( client, cont_i );
else {
u32 temprate_hi, temprate_lo;
rc = TBenchmark( client, cont_i, benchsecs, 0, &temprate_hi, &temprate_lo );
if (rc > 0 && selcorestatics.corenum[cont_i] == hardcoded) {
refrate_hi = temprate_hi;
refrate_lo = temprate_lo;
}
if (rc > 0 && (temprate_hi > bestrate_hi || (temprate_hi == bestrate_hi && temprate_lo > bestrate_lo))) {
bestrate_hi = temprate_hi;
bestrate_lo = temprate_lo;
fastest = selcorestatics.corenum[cont_i];
}
}
#if (CLIENT_OS != OS_WIN32 || !defined(SMC))
if (rc <= 0) /* failed (<0) or not supported (0) */
break; /* stop */
#else
// HACK! to ignore failed benchmark for x86 rc5 smc core #7 if
// started from menu and another cruncher is active in background.
if (rc <= 0) /* failed (<0) or not supported (0) */
{
if ( which == 'b' && cont_i == RC5 && coreidx == 7 )
; /* continue */
else
break; /* stop */
}
#endif
}
} /* for (coreidx = 0; coreidx < corecount; coreidx++) */
selcorestatics.user_cputype[cont_i] = user_cputype;
selcorestatics.corenum[cont_i] = corenum;
/* Summarize the results if multiple cores have been benchmarked (#4108) */
#if (CLIENT_CPU != CPU_CELLBE)
/* Not applicable for Cell due to PPU/SPU core selection hacks */
if (in_corenum < 0 && fastest >= 0 && (bestrate_hi != 0 || bestrate_lo != 0)) {
double percent = 100.0 * ((double)refrate_hi * 4294967296.0 + (double)refrate_lo) /
((double)bestrate_hi * 4294967296.0 + (double)bestrate_lo);
char bestrate_str[32], refrate_str[32];
U64stringify(bestrate_str, sizeof(bestrate_str), bestrate_hi, bestrate_lo, 2, CliGetContestUnitFromID(cont_i));
U64stringify(refrate_str, sizeof(refrate_str), refrate_hi, refrate_lo, 2, CliGetContestUnitFromID(cont_i));
Log("%s benchmark summary :\n"
"Default core : #%d (%s) %s/sec\n"
"Fastest core : #%d (%s) %s/sec\n",
CliGetContestNameFromID(cont_i), hardcoded,
(hardcoded >= 0 ? selcoreGetDisplayName(cont_i, hardcoded) : "undefined"),
refrate_str,
fastest, selcoreGetDisplayName(cont_i, fastest), bestrate_str);
if (percent < 100 && hardcoded >= 0 && hardcoded != fastest) {
if (percent >= 97) {
Log("Core #%d is marginally faster than the default core.\n"
"Testing variability might lead to pick one or the other.\n",
fastest);
}
else {
Log("Core #%d is significantly faster than the default core.\n"
#if (CLIENT_CPU != CPU_CUDA && CLIENT_CPU != CPU_ATI_STREAM && CLIENT_CPU != CPU_OPENCL)
"Please file a bug report along with the output of\n-cpuinfo.\n"
#else
"The GPU core selection has been made as a tradeoff between core speed\n"
"and responsiveness of the graphical desktop.\n"
"Please file a bug report along with the output of -gpuinfo\n"
"only if the the faster core selection does not degrade graphics performance.\n"
#endif
"Changes in cores and selection are frequently made,\n"
"so be sure to test with the latest client version,\n"
"typically a pre-release, before filing a bug report.\n",
fastest);
}
}
}
#endif // CPU_CELLBE
#if (CLIENT_OS == OS_RISCOS) && defined(HAVE_X86_CARD_SUPPORT)
if (rc > 0 && cont_i == RC5 &&
GetNumberOfDetectedProcessors() > 1) /* have x86 card */
{
Problem *prob = ProblemAlloc(); /* so bench/test gets threadnum+1 */ /* FIXME: not true anymore */
rc = -1; /* assume alloc failed */
if (prob)
{
Log("RC5: using x86 core.\n" );
if (which != 's') /* bench */
rc = TBenchmark( client, cont_i, benchsecs, 0 );
else
rc = SelfTest( client, cont_i );
ProblemFree(prob);
}
}
#endif
} /* if (cont_i < CONTEST_COUNT) */
return rc;
}
void main(){
Storage$I();
InitElems();
StressTest();
} /* main */
int
main(void)
{
// OSErr err;
printf("hello world\n");
unsigned long now = time(0);
srand(now);
nsCOMPtr<nsIFile> file;
nsCOMPtr<nsIFile> localFile;
nsresult rv = NS_OK;
{
// Start up XPCOM
nsCOMPtr<nsIServiceManager> servMan;
NS_InitXPCOM2(getter_AddRefs(servMan), nsnull, nsnull);
nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servMan);
NS_ASSERTION(registrar, "Null nsIComponentRegistrar");
if (registrar)
registrar->AutoRegister(nsnull);
// Get default directory
rv = NS_GetSpecialDirectory(NS_XPCOM_CURRENT_PROCESS_DIR,
getter_AddRefs(file));
if (NS_FAILED(rv)) {
printf("NS_GetSpecialDirectory() failed : 0x%.8x\n", rv);
goto exit;
}
char * currentDirPath;
rv = file->GetPath(¤tDirPath);
if (NS_FAILED(rv)) {
printf("currentProcessDir->GetPath() failed : 0x%.8x\n", rv);
goto exit;
}
printf("Current Process Directory: %s\n", currentDirPath);
// Generate name for cache block file
rv = file->Append("_CACHE_001_");
if (NS_FAILED(rv)) goto exit;
// Delete existing file
rv = file->Delete(false);
if (NS_FAILED(rv) && rv != NS_ERROR_FILE_NOT_FOUND) goto exit;
// Need nsIFile to open
localFile = do_QueryInterface(file, &rv);
if (NS_FAILED(rv)) {
printf("do_QueryInterface(file) failed : 0x%.8x\n", rv);
goto exit;
}
nsDiskCacheBlockFile * blockFile = new nsDiskCacheBlockFile;
if (!blockFile) {
rv = NS_ERROR_OUT_OF_MEMORY;
goto exit;
}
//----------------------------------------------------------------
// local variables used in tests
//----------------------------------------------------------------
PRUint32 bytesWritten = 0;
PRInt32 startBlock;
PRInt32 i = 0;
//----------------------------------------------------------------
// Test 1: Open nonexistent file
//----------------------------------------------------------------
rv = blockFile->Open(localFile, 256);
if (NS_FAILED(rv)) {
printf("Test 1: failed (Open returned: 0x%.8x)\n", rv);
goto exit;
}
rv = blockFile->Close();
if (NS_FAILED(rv)) {
printf("Test 1: failed (Close returned: 0x%.8x)\n", rv);
goto exit;
}
printf("Test 1: passed\n");
//----------------------------------------------------------------
// Test 2: Open existing file (with no allocation)
//----------------------------------------------------------------
rv = blockFile->Open(localFile, 256);
if (NS_FAILED(rv)) {
printf("Test 2: failed (Open returned: 0x%.8x)\n", rv);
goto exit;
}
rv = blockFile->Close();
if (NS_FAILED(rv)) {
printf("Test 2: failed (Close returned: 0x%.8x)\n", rv);
goto exit;
}
printf("Test 2: passed\n");
//----------------------------------------------------------------
// Test 3: Open existing file (bad format) size < kBitMapBytes
//----------------------------------------------------------------
// Delete existing file
rv = localFile->Delete(false);
if (NS_FAILED(rv)) {
printf("Test 3 failed (Delete returned: 0x%.8x)\n", rv);
goto exit;
}
// write < kBitMapBytes to file
nsANSIFileStream * stream = new nsANSIFileStream;
if (!stream) {
printf("Test 3 failed (unable to allocate stream\n", rv);
goto exit;
}
NS_ADDREF(stream);
rv = stream->Open(localFile);
if (NS_FAILED(rv)) {
NS_RELEASE(stream);
printf("Test 3 failed (stream->Open returned: 0x%.8x)\n", rv);
goto exit;
}
bytesWritten = 0;
rv = stream->Write("Tell me something good.\n", 24, &bytesWritten);
if (NS_FAILED(rv)) {
NS_RELEASE(stream);
printf("Test 3 failed (stream->Write returned: 0x%.8x)\n", rv);
goto exit;
}
rv = stream->Close();
if (NS_FAILED(rv)) {
NS_RELEASE(stream);
printf("Test 3 failed (stream->Close returned: 0x%.8x)\n", rv);
goto exit;
}
NS_RELEASE(stream);
rv = blockFile->Open(localFile, 256);
if (NS_SUCCEEDED(rv)) {
printf("Test 3: failed (Open erroneously succeeded)\n", rv);
(void) blockFile->Close();
goto exit;
}
printf("Test 3: passed\n");
//----------------------------------------------------------------
// Test 4: Open nonexistent file (again)
//----------------------------------------------------------------
// Delete existing file
rv = localFile->Delete(false);
if (NS_FAILED(rv)) {
printf("Test 4 failed (Delete returned: 0x%.8x)\n", rv);
goto exit;
}
rv = blockFile->Open(localFile, 256);
if (NS_FAILED(rv)) {
printf("Test 4: failed (Open returned: 0x%.8x)\n", rv);
goto exit;
}
printf("Test 4: passed\n");
//----------------------------------------------------------------
// Test 5: AllocateBlocks: invalid block count (0, 5)
//----------------------------------------------------------------
startBlock = blockFile->AllocateBlocks(0);
if (startBlock > -1) {
printf("Test 5: failed (AllocateBlocks(0) erroneously succeeded)\n");
goto exit;
}
startBlock = blockFile->AllocateBlocks(5);
if (startBlock > -1) {
printf("Test 5: failed (AllocateBlocks(5) erroneously succeeded)\n");
goto exit;
}
printf("Test 5: passed\n");
//----------------------------------------------------------------
// Test 6: AllocateBlocks: valid block count (1, 2, 3, 4)
//----------------------------------------------------------------
startBlock = blockFile->AllocateBlocks(1);
if (startBlock != 0) {
printf("Test 6: failed (AllocateBlocks(1) failed)\n");
goto exit;
}
startBlock = blockFile->AllocateBlocks(2);
if (startBlock != 1) {
printf("Test 6: failed (AllocateBlocks(2) failed)\n");
goto exit;
}
startBlock = blockFile->AllocateBlocks(3);
if (startBlock != 4) {
printf("Test 6: failed (AllocateBlocks(3) failed)\n");
goto exit;
}
startBlock = blockFile->AllocateBlocks(4);
if (startBlock != 8) {
printf("Test 6: failed (AllocateBlocks(4) failed)\n");
goto exit;
}
// blocks allocated should be 1220 3330 4444
printf("Test 6: passed\n"); // but bits could be mis-allocated
//----------------------------------------------------------------
// Test 7: VerifyAllocation
//----------------------------------------------------------------
rv = blockFile->VerifyAllocation(0,1);
if (NS_FAILED(rv)) {
printf("Test 7: failed (VerifyAllocation(0,1) returned: 0x%.8x)\n", rv);
goto exit;
}
rv = blockFile->VerifyAllocation(1,2);
if (NS_FAILED(rv)) {
printf("Test 7: failed (VerifyAllocation(1,2) returned: 0x%.8x)\n", rv);
goto exit;
}
rv = blockFile->VerifyAllocation(4,3);
if (NS_FAILED(rv)) {
printf("Test 7: failed (VerifyAllocation(4,3) returned: 0x%.8x)\n", rv);
goto exit;
}
rv = blockFile->VerifyAllocation(8,4);
if (NS_FAILED(rv)) {
printf("Test 7: failed (VerifyAllocation(8,4) returned: 0x%.8x)\n", rv);
goto exit;
}
printf("Test 7: passed\n");
//----------------------------------------------------------------
// Test 8: LastBlock
//----------------------------------------------------------------
PRInt32 lastBlock = blockFile->LastBlock();
if (lastBlock != 11) {
printf("Test 8: failed (LastBlock() returned: %d)\n", lastBlock);
goto exit;
}
printf("Test 8: passed\n");
//----------------------------------------------------------------
// Test 9: DeallocateBlocks: bad startBlock ( < 0)
//----------------------------------------------------------------
rv = blockFile->DeallocateBlocks(-1, 4);
if (NS_SUCCEEDED(rv)) {
printf("Test 9: failed (DeallocateBlocks(-1, 4) erroneously succeeded)\n");
goto exit;
}
printf("Test 9: passed\n");
//----------------------------------------------------------------
// Test 10: DeallocateBlocks: bad numBlocks (0, 5)
//----------------------------------------------------------------
rv = blockFile->DeallocateBlocks(0, 0);
if (NS_SUCCEEDED(rv)) {
printf("Test 10: failed (DeallocateBlocks(0, 0) erroneously succeeded)\n");
goto exit;
}
rv = blockFile->DeallocateBlocks(0, 5);
if (NS_SUCCEEDED(rv)) {
printf("Test 10: failed (DeallocateBlocks(0, 5) erroneously succeeded)\n");
goto exit;
}
printf("Test 10: passed\n");
//----------------------------------------------------------------
// Test 11: DeallocateBlocks: unallocated blocks
//----------------------------------------------------------------
rv = blockFile->DeallocateBlocks(12, 1);
if (NS_SUCCEEDED(rv)) {
printf("Test 11: failed (DeallocateBlocks(12, 1) erroneously succeeded)\n");
goto exit;
}
printf("Test 11: passed\n");
//----------------------------------------------------------------
// Test 12: DeallocateBlocks: 1, 2, 3, 4 (allocated in Test 6)
//----------------------------------------------------------------
rv = blockFile->DeallocateBlocks(0, 1);
if (NS_FAILED(rv)) {
printf("Test 12: failed (DeallocateBlocks(12, 1) returned: 0x%.8x)\n", rv);
goto exit;
}
rv = blockFile->DeallocateBlocks(1, 2);
if (NS_FAILED(rv)) {
printf("Test 12: failed (DeallocateBlocks(1, 2) returned: 0x%.8x)\n", rv);
goto exit;
}
rv = blockFile->DeallocateBlocks(4, 3);
if (NS_FAILED(rv)) {
printf("Test 12: failed (DeallocateBlocks(4, 3) returned: 0x%.8x)\n", rv);
goto exit;
}
rv = blockFile->DeallocateBlocks(8, 4);
if (NS_FAILED(rv)) {
printf("Test 12: failed (DeallocateBlocks(8, 4) returned: 0x%.8x)\n", rv);
goto exit;
}
// zero blocks should be allocated
rv = blockFile->Close();
if (NS_FAILED(rv)) {
printf("Test 12: failed (Close returned: 0x%.8x)\n", rv);
goto exit;
}
printf("Test 12: passed\n");
//----------------------------------------------------------------
// Test 13: Allocate/Deallocate boundary test
//----------------------------------------------------------------
rv = blockFile->Open(localFile, 256);
if (NS_FAILED(rv)) {
printf("Test 13: failed (Open returned: 0x%.8x)\n", rv);
goto exit;
}
// fully allocate, 1 block at a time
for (i=0; i< kBitMapBytes * 8; ++i) {
startBlock = blockFile->AllocateBlocks(1);
if (startBlock < 0) {
printf("Test 13: failed (AllocateBlocks(1) failed on i=%d)\n", i);
goto exit;
}
}
// attempt allocation with full bit map
startBlock = blockFile->AllocateBlocks(1);
if (startBlock >= 0) {
printf("Test 13: failed (AllocateBlocks(1) erroneously succeeded i=%d)\n", i);
goto exit;
}
// deallocate all the bits
for (i=0; i< kBitMapBytes * 8; ++i) {
rv = blockFile->DeallocateBlocks(i,1);
if (NS_FAILED(rv)) {
printf("Test 13: failed (DeallocateBlocks(%d,1) returned: 0x%.8x)\n", i,rv);
goto exit;
}
}
// attempt deallocation beyond end of bit map
rv = blockFile->DeallocateBlocks(i,1);
if (NS_SUCCEEDED(rv)) {
printf("Test 13: failed (DeallocateBlocks(%d,1) erroneously succeeded)\n", i);
goto exit;
}
// bit map should be empty
// fully allocate, 2 block at a time
for (i=0; i< kBitMapBytes * 8; i+=2) {
startBlock = blockFile->AllocateBlocks(2);
if (startBlock < 0) {
printf("Test 13: failed (AllocateBlocks(2) failed on i=%d)\n", i);
goto exit;
}
}
// attempt allocation with full bit map
startBlock = blockFile->AllocateBlocks(2);
if (startBlock >= 0) {
printf("Test 13: failed (AllocateBlocks(2) erroneously succeeded i=%d)\n", i);
goto exit;
}
// deallocate all the bits
for (i=0; i< kBitMapBytes * 8; i+=2) {
rv = blockFile->DeallocateBlocks(i,2);
if (NS_FAILED(rv)) {
printf("Test 13: failed (DeallocateBlocks(%d,2) returned: 0x%.8x)\n", i,rv);
goto exit;
}
}
// bit map should be empty
// fully allocate, 4 block at a time
for (i=0; i< kBitMapBytes * 8; i+=4) {
startBlock = blockFile->AllocateBlocks(4);
if (startBlock < 0) {
printf("Test 13: failed (AllocateBlocks(4) failed on i=%d)\n", i);
goto exit;
}
}
// attempt allocation with full bit map
startBlock = blockFile->AllocateBlocks(4);
if (startBlock >= 0) {
printf("Test 13: failed (AllocateBlocks(4) erroneously succeeded i=%d)\n", i);
goto exit;
}
// deallocate all the bits
for (i=0; i< kBitMapBytes * 8; i+=4) {
rv = blockFile->DeallocateBlocks(i,4);
if (NS_FAILED(rv)) {
printf("Test 13: failed (DeallocateBlocks(%d,4) returned: 0x%.8x)\n", i,rv);
goto exit;
}
}
// bit map should be empty
// allocate as many triple-blocks as possible
for (i=0; i< kBitMapBytes * 8; i+=4) {
startBlock = blockFile->AllocateBlocks(3);
if (startBlock < 0) {
printf("Test 13: failed (AllocateBlocks(3) failed on i=%d)\n", i);
goto exit;
}
}
// attempt allocation with "full" bit map
startBlock = blockFile->AllocateBlocks(3);
if (startBlock >= 0) {
printf("Test 13: failed (AllocateBlocks(3) erroneously succeeded i=%d)\n", i);
goto exit;
}
// leave some blocks allocated
rv = blockFile->Close();
if (NS_FAILED(rv)) {
printf("Test 13: failed (Close returned: 0x%.8x)\n", rv);
goto exit;
}
printf("Test 13: passed\n");
//----------------------------------------------------------------
// Test 14: ValidateFile (open existing file w/size < allocated blocks
//----------------------------------------------------------------
rv = blockFile->Open(localFile, 256);
if (NS_SUCCEEDED(rv)) {
printf("Test 14: failed (Open erroneously succeeded)\n");
goto exit;
}
// Delete existing file
rv = localFile->Delete(false);
if (NS_FAILED(rv)) {
printf("Test 14 failed (Delete returned: 0x%.8x)\n", rv);
goto exit;
}
printf("Test 14: passed\n");
//----------------------------------------------------------------
// Test 15: Allocate/Deallocate stress test
//----------------------------------------------------------------
rv = StressTest(localFile, 15, false);
if (NS_FAILED(rv))
goto exit;
printf("Test 15: passed\n");
//----------------------------------------------------------------
// Test 16: WriteBlocks
//----------------------------------------------------------------
rv = blockFile->Open(localFile, 256);
if (NS_FAILED(rv)) {
printf("Test 16: failed (Open returned: 0x%.8x)\n", rv);
goto exit;
}
char * one = new char[256 * 1];
char * two = new char[256 * 2];
char * three = new char[256 * 3];
char * four = new char[256 * 4];
if (!one || !two || !three || !four) {
printf("Test 16: failed - out of memory\n");
rv = NS_ERROR_OUT_OF_MEMORY;
goto exit;
}
memset(one, 1, 256);
memset(two, 2, 256 * 2);
memset(three, 3, 256 * 3);
memset(four, 4, 256 * 4);
startBlock = blockFile->AllocateBlocks(1);
if (startBlock != 0) {
printf("Test 16: failed (AllocateBlocks(1) failed)\n");
goto exit;
}
rv = blockFile->WriteBlocks(one, startBlock, 1);
if (NS_FAILED(rv)) {
printf("Test 16: failed (WriteBlocks(1) returned 0x%.8x)\n", rv);
goto exit;
}
startBlock = blockFile->AllocateBlocks(2);
if (startBlock != 1) { // starting with empy map, this allocation should begin at block 1
printf("Test 16: failed (AllocateBlocks(2) failed)\n");
goto exit;
}
rv = blockFile->WriteBlocks(two, startBlock, 2);
if (NS_FAILED(rv)) {
printf("Test 16: failed (WriteBlocks(2) returned 0x%.8x)\n", rv);
goto exit;
}
startBlock = blockFile->AllocateBlocks(3);
if (startBlock != 4) { // starting with empy map, this allocation should begin at block 4
printf("Test 16: failed (AllocateBlocks(3) failed)\n");
goto exit;
}
rv = blockFile->WriteBlocks(three, startBlock, 3);
if (NS_FAILED(rv)) {
printf("Test 16: failed (WriteBlocks(3) returned 0x%.8x)\n", rv);
goto exit;
}
startBlock = blockFile->AllocateBlocks(4);
if (startBlock != 8) { // starting with empy map, this allocation should begin at block 8
printf("Test 16: failed (AllocateBlocks(4) failed)\n");
goto exit;
}
rv = blockFile->WriteBlocks(four, startBlock, 4);
if (NS_FAILED(rv)) {
printf("Test 16: failed (WriteBlocks(4) returned 0x%.8x)\n", rv);
goto exit;
}
printf("Test 16: passed\n");
//----------------------------------------------------------------
// Test 17: ReadBlocks
//----------------------------------------------------------------
rv = blockFile->ReadBlocks(one, 0, 1);
if (NS_FAILED(rv)) {
printf("Test 17: failed (ReadBlocks(1) returned 0x%.8x)\n", rv);
goto exit;
}
// Verify buffer
for (i = 0; i < 256; i++) {
if (one[i] != 1) {
printf("Test 17: failed (verifying buffer 1)\n");
rv = NS_ERROR_FAILURE;
goto exit;
}
}
rv = blockFile->ReadBlocks(two, 1, 2);
if (NS_FAILED(rv)) {
printf("Test 17: failed (ReadBlocks(2) returned 0x%.8x)\n", rv);
goto exit;
}
// Verify buffer
for (i = 0; i < 256 * 2; i++) {
if (two[i] != 2) {
printf("Test 17: failed (verifying buffer 2)\n");
rv = NS_ERROR_FAILURE;
goto exit;
}
}
rv = blockFile->ReadBlocks(three, 4, 3);
if (NS_FAILED(rv)) {
printf("Test 17: failed (ReadBlocks(3) returned 0x%.8x)\n", rv);
goto exit;
}
// Verify buffer
for (i = 0; i < 256 * 3; i++) {
if (three[i] != 3) {
printf("Test 17: failed (verifying buffer 3)\n");
rv = NS_ERROR_FAILURE;
goto exit;
}
}
rv = blockFile->ReadBlocks(four, 8, 4);
if (NS_FAILED(rv)) {
printf("Test 17: failed (ReadBlocks(4) returned 0x%.8x)\n", rv);
goto exit;
}
// Verify buffer
for (i = 0; i < 256 * 4; i++) {
if (four[i] != 4) {
printf("Test 17: failed (verifying buffer 4)\n");
rv = NS_ERROR_FAILURE;
goto exit;
}
}
rv = blockFile->Close();
if (NS_FAILED(rv)) {
printf("Test 17: failed (Close returned: 0x%.8x)\n", rv);
goto exit;
}
printf("Test 17: passed\n");
//----------------------------------------------------------------
// Test 18: ValidateFile (open existing file with blocks allocated)
//----------------------------------------------------------------
rv = blockFile->Open(localFile, 256);
if (NS_FAILED(rv)) {
printf("Test 18: failed (Open returned: 0x%.8x)\n", rv);
goto exit;
}
rv = blockFile->Close();
if (NS_FAILED(rv)) {
printf("Test 18: failed (Close returned: 0x%.8x)\n", rv);
goto exit;
}
printf("Test 18: passed\n");
//----------------------------------------------------------------
// Test 19: WriteBlocks/ReadBlocks stress
//----------------------------------------------------------------
rv = StressTest(localFile, 19, false);
if (NS_FAILED(rv))
goto exit;
printf("Test 19: passed\n");
exit:
if (currentDirPath)
nsMemory::Free(currentDirPath);
} // this scopes the nsCOMPtrs
// no nsCOMPtrs are allowed to be alive when you call NS_ShutdownXPCOM
if (NS_FAILED(rv))
printf("Test failed: 0x%.8x\n", rv);
rv = NS_ShutdownXPCOM(nsnull);
NS_ASSERTION(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
printf("XPCOM shut down.\n\n");
return 0;
}
void main (void) {
OSCQueue q;
myObj *item;
q = OSCNewQueue(100, Allocator);
if (q == 0) {
printf("OSCNewQueue() returned 0!\n");
return;
}
printf("Made an empty queue: ");
OSCQueuePrint(q);
printf("Inserting three objects.\n");
objects[0].timetag = 5;
objects[0].data = "five";
objects[1].timetag = 2;
objects[1].data = "two";
objects[2].timetag = 7;
objects[2].data = "seven";
if (OSCQueueInsert(q, (OSCSchedulableObject) &(objects[0])) == FALSE) {
printf("OSCQueueInsert() returned FALSE!\n");
return;
}
if (OSCQueueInsert(q, (OSCSchedulableObject) &(objects[1])) == FALSE) {
printf("OSCQueueInsert() returned FALSE!\n");
return;
}
if (OSCQueueInsert(q, (OSCSchedulableObject) &(objects[2])) == FALSE) {
printf("OSCQueueInsert() returned FALSE!\n");
return;
}
printf("Queue with three objects: ");
OSCQueuePrint(q);
printf("Earliest time tag is %llu.\n", OSCQueueEarliestTimeTag(q));
printf("Remove front item:\n");
item = (myObj *) OSCQueueRemoveEarliest(q);
printf("Time tag %llu, data %s\n", item->timetag, item->data);
printf("Queue with two objects: ");
OSCQueuePrint(q);
printf("Inserting three more objects.\n");
objects[3].timetag = 11;
objects[3].data = "eleven";
objects[4].timetag = 6;
objects[4].data = "six";
objects[5].timetag = 3;
objects[5].data = "three";
if (OSCQueueInsert(q, (OSCSchedulableObject) &(objects[3])) == FALSE) {
printf("OSCQueueInsert() returned FALSE!\n");
return;
}
if (OSCQueueInsert(q, (OSCSchedulableObject) &(objects[4])) == FALSE) {
printf("OSCQueueInsert() returned FALSE!\n");
return;
}
if (OSCQueueInsert(q, (OSCSchedulableObject) &(objects[5])) == FALSE) {
printf("OSCQueueInsert() returned FALSE!\n");
return;
}
printf("Queue with five objects: ");
OSCQueuePrint(q);
ScanTest(q);
StressTest(q);
printf("Done!\n");
}
