epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 1 | |
reed@google.com | dde0956 | 2011-05-23 12:21:05 +0000 | [diff] [blame] | 2 | /* |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 3 | * Copyright 2011 Google Inc. |
| 4 | * |
| 5 | * Use of this source code is governed by a BSD-style license that can be |
| 6 | * found in the LICENSE file. |
reed@google.com | dde0956 | 2011-05-23 12:21:05 +0000 | [diff] [blame] | 7 | */ |
| 8 | |
| 9 | |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 10 | |
reed@google.com | dde0956 | 2011-05-23 12:21:05 +0000 | [diff] [blame] | 11 | #include "SkReader32.h" |
| 12 | #include "SkWriter32.h" |
| 13 | #include "Test.h" |
| 14 | |
reed@google.com | 51c62a6 | 2012-06-12 20:47:53 +0000 | [diff] [blame] | 15 | static void test_ptr(skiatest::Reporter* reporter) { |
| 16 | SkSWriter32<32> writer(32); |
| 17 | |
| 18 | void* p0 = reporter; |
| 19 | void* p1 = &writer; |
| 20 | |
| 21 | // try writing ptrs where at least one of them may be at a non-multiple of |
| 22 | // 8 boundary, to confirm this works on 64bit machines. |
| 23 | |
| 24 | writer.writePtr(p0); |
| 25 | writer.write8(0x33); |
| 26 | writer.writePtr(p1); |
| 27 | writer.write8(0x66); |
| 28 | |
| 29 | size_t size = writer.size(); |
| 30 | REPORTER_ASSERT(reporter, 2 * sizeof(void*) + 2 * sizeof(int32_t)); |
| 31 | |
| 32 | char buffer[32]; |
| 33 | SkASSERT(sizeof(buffer) >= size); |
| 34 | writer.flatten(buffer); |
| 35 | |
| 36 | SkReader32 reader(buffer, size); |
| 37 | REPORTER_ASSERT(reporter, reader.readPtr() == p0); |
| 38 | REPORTER_ASSERT(reporter, reader.readInt() == 0x33); |
| 39 | REPORTER_ASSERT(reporter, reader.readPtr() == p1); |
| 40 | REPORTER_ASSERT(reporter, reader.readInt() == 0x66); |
| 41 | } |
| 42 | |
reed@google.com | dde0956 | 2011-05-23 12:21:05 +0000 | [diff] [blame] | 43 | static void test1(skiatest::Reporter* reporter, SkWriter32* writer) { |
| 44 | const uint32_t data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; |
| 45 | for (size_t i = 0; i < SK_ARRAY_COUNT(data); ++i) { |
| 46 | REPORTER_ASSERT(reporter, i*4 == writer->size()); |
| 47 | writer->write32(data[i]); |
| 48 | uint32_t* addr = writer->peek32(i * 4); |
| 49 | REPORTER_ASSERT(reporter, data[i] == *addr); |
| 50 | } |
| 51 | |
| 52 | char buffer[sizeof(data)]; |
| 53 | REPORTER_ASSERT(reporter, sizeof(buffer) == writer->size()); |
| 54 | writer->flatten(buffer); |
| 55 | REPORTER_ASSERT(reporter, !memcmp(data, buffer, sizeof(buffer))); |
| 56 | } |
| 57 | |
| 58 | static void test2(skiatest::Reporter* reporter, SkWriter32* writer) { |
| 59 | static const char gStr[] = "abcdefghimjklmnopqrstuvwxyz"; |
| 60 | size_t i; |
| 61 | |
| 62 | size_t len = 0; |
| 63 | for (i = 0; i <= 26; ++i) { |
| 64 | len += SkWriter32::WriteStringSize(gStr, i); |
| 65 | writer->writeString(gStr, i); |
| 66 | } |
| 67 | REPORTER_ASSERT(reporter, writer->size() == len); |
| 68 | |
| 69 | SkAutoMalloc storage(len); |
| 70 | writer->flatten(storage.get()); |
| 71 | |
| 72 | SkReader32 reader; |
| 73 | reader.setMemory(storage.get(), len); |
| 74 | for (i = 0; i <= 26; ++i) { |
| 75 | REPORTER_ASSERT(reporter, !reader.eof()); |
| 76 | const char* str = reader.readString(&len); |
| 77 | REPORTER_ASSERT(reporter, i == len); |
| 78 | REPORTER_ASSERT(reporter, strlen(str) == len); |
| 79 | REPORTER_ASSERT(reporter, !memcmp(str, gStr, len)); |
| 80 | } |
| 81 | REPORTER_ASSERT(reporter, reader.eof()); |
| 82 | } |
| 83 | |
| 84 | static void Tests(skiatest::Reporter* reporter) { |
| 85 | // dynamic allocator |
| 86 | { |
| 87 | SkWriter32 writer(256 * 4); |
| 88 | REPORTER_ASSERT(reporter, NULL == writer.getSingleBlock()); |
| 89 | test1(reporter, &writer); |
| 90 | |
| 91 | writer.reset(); |
| 92 | test2(reporter, &writer); |
| 93 | } |
| 94 | |
| 95 | // single-block |
| 96 | { |
| 97 | SkWriter32 writer(0); |
| 98 | uint32_t storage[256]; |
| 99 | REPORTER_ASSERT(reporter, NULL == writer.getSingleBlock()); |
| 100 | writer.reset(storage, sizeof(storage)); |
| 101 | REPORTER_ASSERT(reporter, (void*)storage == writer.getSingleBlock()); |
| 102 | test1(reporter, &writer); |
| 103 | |
| 104 | writer.reset(storage, sizeof(storage)); |
| 105 | test2(reporter, &writer); |
| 106 | } |
reed@google.com | e49aca9 | 2012-04-24 21:12:39 +0000 | [diff] [blame] | 107 | |
| 108 | // small storage |
| 109 | { |
reed@google.com | 51c62a6 | 2012-06-12 20:47:53 +0000 | [diff] [blame] | 110 | SkSWriter32<8 * sizeof(intptr_t)> writer(100); |
reed@google.com | e49aca9 | 2012-04-24 21:12:39 +0000 | [diff] [blame] | 111 | test1(reporter, &writer); |
| 112 | writer.reset(); // should just rewind our storage |
| 113 | test2(reporter, &writer); |
| 114 | } |
| 115 | |
| 116 | // large storage |
| 117 | { |
reed@google.com | 51c62a6 | 2012-06-12 20:47:53 +0000 | [diff] [blame] | 118 | SkSWriter32<1024 * sizeof(intptr_t)> writer(100); |
reed@google.com | e49aca9 | 2012-04-24 21:12:39 +0000 | [diff] [blame] | 119 | test1(reporter, &writer); |
| 120 | writer.reset(); // should just rewind our storage |
| 121 | test2(reporter, &writer); |
| 122 | } |
reed@google.com | 51c62a6 | 2012-06-12 20:47:53 +0000 | [diff] [blame] | 123 | |
| 124 | test_ptr(reporter); |
reed@google.com | dde0956 | 2011-05-23 12:21:05 +0000 | [diff] [blame] | 125 | } |
| 126 | |
| 127 | #include "TestClassDef.h" |
| 128 | DEFINE_TESTCLASS("Writer32", Writer32Class, Tests) |
| 129 | |