Home | History | Annotate | Download | only in tests 
      1 #include "Test.h"
      2 #include "SkRandom.h"
      3 #include "SkStream.h"
      4 
      5 #define MAX_SIZE    (256 * 1024)
      6 
      7 static void random_fill(SkRandom& rand, void* buffer, size_t size) {
      8     char* p = (char*)buffer;
      9     char* stop = p + size;
     10     while (p < stop) {
     11         *p++ = (char)(rand.nextU() >> 8);
     12     }
     13 }
     14 
     15 static void test_buffer(skiatest::Reporter* reporter) {
     16     SkRandom rand;
     17     SkAutoMalloc am(MAX_SIZE * 2);
     18     char* storage = (char*)am.get();
     19     char* storage2 = storage + MAX_SIZE;
     20 
     21     random_fill(rand, storage, MAX_SIZE);
     22 
     23     for (int sizeTimes = 0; sizeTimes < 100; sizeTimes++) {
     24         int size = rand.nextU() % MAX_SIZE;
     25         if (size == 0) {
     26             size = MAX_SIZE;
     27         }
     28         for (int times = 0; times < 100; times++) {
     29             int bufferSize = 1 + (rand.nextU() & 0xFFFF);
     30             SkMemoryStream mstream(storage, size);
     31             SkBufferStream bstream(&mstream, bufferSize);
     32 
     33             int bytesRead = 0;
     34             while (bytesRead < size) {
     35                 int s = 17 + (rand.nextU() & 0xFFFF);
     36                 int ss = bstream.read(storage2, s);
     37                 REPORTER_ASSERT(reporter, ss > 0 && ss <= s);
     38                 REPORTER_ASSERT(reporter, bytesRead + ss <= size);
     39                 REPORTER_ASSERT(reporter,
     40                                 memcmp(storage + bytesRead, storage2, ss) == 0);
     41                 bytesRead += ss;
     42             }
     43             REPORTER_ASSERT(reporter, bytesRead == size);
     44         }
     45     }
     46 }
     47 
     48 static void TestRStream(skiatest::Reporter* reporter) {
     49     static const char s[] =
     50         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     51     char            copy[sizeof(s)];
     52     SkRandom        rand;
     53 
     54     for (int i = 0; i < 65; i++) {
     55         char*           copyPtr = copy;
     56         SkMemoryStream  mem(s, sizeof(s));
     57         SkBufferStream  buff(&mem, i);
     58 
     59         do {
     60             copyPtr += buff.read(copyPtr, rand.nextU() & 15);
     61         } while (copyPtr < copy + sizeof(s));
     62         REPORTER_ASSERT(reporter, copyPtr == copy + sizeof(s));
     63         REPORTER_ASSERT(reporter, memcmp(s, copy, sizeof(s)) == 0);
     64     }
     65     test_buffer(reporter);
     66 }
     67 
     68 static void TestWStream(skiatest::Reporter* reporter) {
     69     SkDynamicMemoryWStream  ds;
     70     const char s[] = "abcdefghijklmnopqrstuvwxyz";
     71     int i;
     72     for (i = 0; i < 100; i++) {
     73         REPORTER_ASSERT(reporter, ds.write(s, 26));
     74     }
     75     REPORTER_ASSERT(reporter, ds.getOffset() == 100 * 26);
     76     char* dst = new char[100 * 26 + 1];
     77     dst[100*26] = '*';
     78     ds.copyTo(dst);
     79     REPORTER_ASSERT(reporter, dst[100*26] == '*');
     80 //     char* p = dst;
     81     for (i = 0; i < 100; i++) {
     82         REPORTER_ASSERT(reporter, memcmp(&dst[i * 26], s, 26) == 0);
     83     }
     84     REPORTER_ASSERT(reporter, memcmp(dst, ds.getStream(), 100*26) == 0);
     85     delete[] dst;
     86 }
     87 
     88 static void TestStreams(skiatest::Reporter* reporter) {
     89     TestRStream(reporter);
     90     TestWStream(reporter);
     91 }
     92 
     93 #include "TestClassDef.h"
     94 DEFINE_TESTCLASS("Stream", StreamTestClass, TestStreams)
     95