Esempio n. 1
0
void TestStream()
{
    char buf[256];
    char streambuf[256];
    ostrstream stream(streambuf, sizeof(streambuf));

    F32 f = 612341.1231F;
    U32 u = 243523434;
    char *s = "lk2345;lk2hj3;4kjgl52";

    Clock::CycleWatch t1, t2;

    for (int i = 0; i < 1000; i++)
    {
        stream.seekp(0, ios::beg);

        t1.Start();
        stream << f << ' ' << u << ' ' << s << '\0';
        t1.Stop();

        t2.Start();
        Utils::Sprintf(buf, sizeof(buf), "%f %u %s", f, u, s);
        t2.Stop();
    }

    TestWrite("strstream='%s'", stream.str());
    TestWrite("sprintf='%s'", buf);
    TestWrite("");

    TestReport("strstream", t1);
    TestReport("sprintf", t2);
}
Esempio n. 2
0
unsigned QWrite( f_handle file, void *buffer, unsigned len, char *name )
/*****************************************************************************/
{
    while( len > (16*1024) ) {
        if( TestWrite( file, buffer, 16*1024, name ) != 16*1024 ) return 0;
        len -= 16*1024;
        buffer = ((char *) buffer) + 16*1024;
    }
    return TestWrite( file, buffer, len, name );
}
Esempio n. 3
0
///////////////////////////////////////////////////////////////////////////////
//
// CRC
//
void TestCRC()
{
    const int testLen[] = {1, 8, 64, 255};
    const int numTests = sizeof(testLen)/sizeof(testLen[0]);

    //
    // Crc timing runs
    //
    Clock::CycleWatch t1, t2, t3;
    char buf[256];
    int runs = 500;

    srand(0);

    for (int test = 0; test < numTests; test++)
    {
        // Fill the buffer
        int len = testLen[test];
        for (int j = 0; j < len; j++)
        {
            buf[j] = (U8)((rand() % 255) + 1);
        }
        buf[len] = 0;

        // Run some tests
        t1.Reset();
        t2.Reset();
        t3.Reset();

        for (int i = 0; i < runs; i++)
        {
            // crc
            t1.Start();
            Crc::Calc(buf, len);
            t1.Stop();

            // crclower
            t2.Start();
            Crc::CalcLower(buf, len);
            t2.Stop();

            // calcstr
            t3.Start();
            Crc::CalcStr(buf, len);
            t3.Stop();
        }

        TestWrite("Buffer of length %d", len);
        TestWrite("");
        TestReport("Crc::Calc", t1);
        TestReport("Crc::CalcLower", t2);
        TestReport("Crc::CalcStr", t3);
        TestWrite("");
    }
}
Esempio n. 4
0
int main(int argc, char * argv[])
{
	LOGD("Test started");

	LOGD("Testing reads");
	TestRead();

	LOGD("Testing writes");
	TestWrite();

	LOGD("Testing wraps");
	TestWrap();

	LOG("ByteBuffer test finished.");
}
/** This function is testing the TrackingVolume class. */
int mitkNavigationToolReaderAndWriterTest(int /* argc */, char* /*argv*/[])
{
  MITK_TEST_BEGIN("NavigationToolWriter")

  TestInstantiation();
  TestWrite();
  TestRead();
  TestWrite2();
  TestRead2();
  TestReadInvalidData();
  TestWriteInvalidData();
  CleanUp();

  MITK_TEST_END()
}