1 /* 2 * Copyright 2011 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #include "SkData.h" 9 #include "SkDataTable.h" 10 #include "SkOSFile.h" 11 #include "SkReadBuffer.h" 12 #include "SkWriteBuffer.h" 13 #include "SkStream.h" 14 #include "Test.h" 15 16 static void test_is_equal(skiatest::Reporter* reporter, 17 const SkDataTable* a, const SkDataTable* b) { 18 REPORTER_ASSERT(reporter, a->count() == b->count()); 19 for (int i = 0; i < a->count(); ++i) { 20 size_t sizea, sizeb; 21 const void* mema = a->at(i, &sizea); 22 const void* memb = b->at(i, &sizeb); 23 REPORTER_ASSERT(reporter, sizea == sizeb); 24 REPORTER_ASSERT(reporter, !memcmp(mema, memb, sizea)); 25 } 26 } 27 28 static void test_datatable_is_empty(skiatest::Reporter* reporter, 29 SkDataTable* table) { 30 REPORTER_ASSERT(reporter, table->isEmpty()); 31 REPORTER_ASSERT(reporter, 0 == table->count()); 32 } 33 34 static void test_emptytable(skiatest::Reporter* reporter) { 35 SkAutoTUnref<SkDataTable> table0(SkDataTable::NewEmpty()); 36 SkAutoTUnref<SkDataTable> table1(SkDataTable::NewCopyArrays(nullptr, nullptr, 0)); 37 SkAutoTUnref<SkDataTable> table2(SkDataTable::NewCopyArray(nullptr, 0, 0)); 38 SkAutoTUnref<SkDataTable> table3(SkDataTable::NewArrayProc(nullptr, 0, 0, 39 nullptr, nullptr)); 40 41 test_datatable_is_empty(reporter, table0); 42 test_datatable_is_empty(reporter, table1); 43 test_datatable_is_empty(reporter, table2); 44 test_datatable_is_empty(reporter, table3); 45 46 test_is_equal(reporter, table0, table1); 47 test_is_equal(reporter, table0, table2); 48 test_is_equal(reporter, table0, table3); 49 } 50 51 static void test_simpletable(skiatest::Reporter* reporter) { 52 const int idata[] = { 1, 4, 9, 16, 25, 63 }; 53 int icount = SK_ARRAY_COUNT(idata); 54 SkAutoTUnref<SkDataTable> itable(SkDataTable::NewCopyArray(idata, 55 sizeof(idata[0]), 56 icount)); 57 REPORTER_ASSERT(reporter, itable->count() == icount); 58 for (int i = 0; i < icount; ++i) { 59 size_t size; 60 REPORTER_ASSERT(reporter, sizeof(int) == itable->atSize(i)); 61 REPORTER_ASSERT(reporter, *itable->atT<int>(i, &size) == idata[i]); 62 REPORTER_ASSERT(reporter, sizeof(int) == size); 63 } 64 } 65 66 static void test_vartable(skiatest::Reporter* reporter) { 67 const char* str[] = { 68 "", "a", "be", "see", "deigh", "ef", "ggggggggggggggggggggggggggg" 69 }; 70 int count = SK_ARRAY_COUNT(str); 71 size_t sizes[SK_ARRAY_COUNT(str)]; 72 for (int i = 0; i < count; ++i) { 73 sizes[i] = strlen(str[i]) + 1; 74 } 75 76 SkAutoTUnref<SkDataTable> table(SkDataTable::NewCopyArrays( 77 (const void*const*)str, sizes, count)); 78 79 REPORTER_ASSERT(reporter, table->count() == count); 80 for (int i = 0; i < count; ++i) { 81 size_t size; 82 REPORTER_ASSERT(reporter, table->atSize(i) == sizes[i]); 83 REPORTER_ASSERT(reporter, !strcmp(table->atT<const char>(i, &size), 84 str[i])); 85 REPORTER_ASSERT(reporter, size == sizes[i]); 86 87 const char* s = table->atStr(i); 88 REPORTER_ASSERT(reporter, strlen(s) == strlen(str[i])); 89 } 90 } 91 92 static void test_tablebuilder(skiatest::Reporter* reporter) { 93 const char* str[] = { 94 "", "a", "be", "see", "deigh", "ef", "ggggggggggggggggggggggggggg" 95 }; 96 int count = SK_ARRAY_COUNT(str); 97 98 SkDataTableBuilder builder(16); 99 100 for (int i = 0; i < count; ++i) { 101 builder.append(str[i], strlen(str[i]) + 1); 102 } 103 SkAutoTUnref<SkDataTable> table(builder.detachDataTable()); 104 105 REPORTER_ASSERT(reporter, table->count() == count); 106 for (int i = 0; i < count; ++i) { 107 size_t size; 108 REPORTER_ASSERT(reporter, table->atSize(i) == strlen(str[i]) + 1); 109 REPORTER_ASSERT(reporter, !strcmp(table->atT<const char>(i, &size), 110 str[i])); 111 REPORTER_ASSERT(reporter, size == strlen(str[i]) + 1); 112 113 const char* s = table->atStr(i); 114 REPORTER_ASSERT(reporter, strlen(s) == strlen(str[i])); 115 } 116 } 117 118 static void test_globaltable(skiatest::Reporter* reporter) { 119 static const int gData[] = { 120 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 121 }; 122 int count = SK_ARRAY_COUNT(gData); 123 124 SkAutoTUnref<SkDataTable> table(SkDataTable::NewArrayProc(gData, 125 sizeof(gData[0]), count, nullptr, nullptr)); 126 127 REPORTER_ASSERT(reporter, table->count() == count); 128 for (int i = 0; i < count; ++i) { 129 size_t size; 130 REPORTER_ASSERT(reporter, table->atSize(i) == sizeof(int)); 131 REPORTER_ASSERT(reporter, *table->atT<const char>(i, &size) == i); 132 REPORTER_ASSERT(reporter, sizeof(int) == size); 133 } 134 } 135 136 DEF_TEST(DataTable, reporter) { 137 test_emptytable(reporter); 138 test_simpletable(reporter); 139 test_vartable(reporter); 140 test_tablebuilder(reporter); 141 test_globaltable(reporter); 142 } 143 144 static void* gGlobal; 145 146 static void delete_int_proc(const void* ptr, void* context) { 147 int* data = (int*)ptr; 148 SkASSERT(context == gGlobal); 149 delete[] data; 150 } 151 152 static void assert_len(skiatest::Reporter* reporter, SkData* ref, size_t len) { 153 REPORTER_ASSERT(reporter, ref->size() == len); 154 } 155 156 static void assert_data(skiatest::Reporter* reporter, SkData* ref, 157 const void* data, size_t len) { 158 REPORTER_ASSERT(reporter, ref->size() == len); 159 REPORTER_ASSERT(reporter, !memcmp(ref->data(), data, len)); 160 } 161 162 static void test_cstring(skiatest::Reporter* reporter) { 163 const char str[] = "Hello world"; 164 size_t len = strlen(str); 165 166 SkAutoTUnref<SkData> r0(SkData::NewWithCopy(str, len + 1)); 167 SkAutoTUnref<SkData> r1(SkData::NewWithCString(str)); 168 169 REPORTER_ASSERT(reporter, r0->equals(r1)); 170 171 SkAutoTUnref<SkData> r2(SkData::NewWithCString(nullptr)); 172 REPORTER_ASSERT(reporter, 1 == r2->size()); 173 REPORTER_ASSERT(reporter, 0 == *r2->bytes()); 174 } 175 176 static void test_files(skiatest::Reporter* reporter) { 177 SkString tmpDir = skiatest::GetTmpDir(); 178 if (tmpDir.isEmpty()) { 179 return; 180 } 181 182 SkString path = SkOSPath::Join(tmpDir.c_str(), "data_test"); 183 184 const char s[] = "abcdefghijklmnopqrstuvwxyz"; 185 { 186 SkFILEWStream writer(path.c_str()); 187 if (!writer.isValid()) { 188 ERRORF(reporter, "Failed to create tmp file %s\n", path.c_str()); 189 return; 190 } 191 writer.write(s, 26); 192 } 193 194 FILE* file = sk_fopen(path.c_str(), kRead_SkFILE_Flag); 195 SkAutoTUnref<SkData> r1(SkData::NewFromFILE(file)); 196 REPORTER_ASSERT(reporter, r1.get() != nullptr); 197 REPORTER_ASSERT(reporter, r1->size() == 26); 198 REPORTER_ASSERT(reporter, strncmp(static_cast<const char*>(r1->data()), s, 26) == 0); 199 200 int fd = sk_fileno(file); 201 SkAutoTUnref<SkData> r2(SkData::NewFromFD(fd)); 202 REPORTER_ASSERT(reporter, r2.get() != nullptr); 203 REPORTER_ASSERT(reporter, r2->size() == 26); 204 REPORTER_ASSERT(reporter, strncmp(static_cast<const char*>(r2->data()), s, 26) == 0); 205 } 206 207 DEF_TEST(Data, reporter) { 208 const char* str = "We the people, in order to form a more perfect union."; 209 const int N = 10; 210 211 SkAutoTUnref<SkData> r0(SkData::NewEmpty()); 212 SkAutoTUnref<SkData> r1(SkData::NewWithCopy(str, strlen(str))); 213 SkAutoTUnref<SkData> r2(SkData::NewWithProc(new int[N], N*sizeof(int), 214 delete_int_proc, gGlobal)); 215 SkAutoTUnref<SkData> r3(SkData::NewSubset(r1, 7, 6)); 216 217 assert_len(reporter, r0, 0); 218 assert_len(reporter, r1, strlen(str)); 219 assert_len(reporter, r2, N * sizeof(int)); 220 assert_len(reporter, r3, 6); 221 222 assert_data(reporter, r1, str, strlen(str)); 223 assert_data(reporter, r3, "people", 6); 224 225 SkData* tmp = SkData::NewSubset(r1, strlen(str), 10); 226 assert_len(reporter, tmp, 0); 227 tmp->unref(); 228 tmp = SkData::NewSubset(r1, 0, 0); 229 assert_len(reporter, tmp, 0); 230 tmp->unref(); 231 232 test_cstring(reporter); 233 test_files(reporter); 234 } 235 236 /////////////////////////////////////////////////////////////////////////////////////////////////// 237 #include "SkRWBuffer.h" 238 239 const char gABC[] = "abcdefghijklmnopqrstuvwxyz"; 240 241 static void check_abcs(skiatest::Reporter* reporter, const char buffer[], size_t size) { 242 REPORTER_ASSERT(reporter, size % 26 == 0); 243 for (size_t offset = 0; offset < size; offset += 26) { 244 REPORTER_ASSERT(reporter, !memcmp(&buffer[offset], gABC, 26)); 245 } 246 } 247 248 // stream should contains an integral number of copies of gABC. 249 static void check_alphabet_stream(skiatest::Reporter* reporter, SkStream* stream) { 250 REPORTER_ASSERT(reporter, stream->hasLength()); 251 size_t size = stream->getLength(); 252 REPORTER_ASSERT(reporter, size % 26 == 0); 253 254 SkAutoTMalloc<char> storage(size); 255 char* array = storage.get(); 256 size_t bytesRead = stream->read(array, size); 257 REPORTER_ASSERT(reporter, bytesRead == size); 258 check_abcs(reporter, array, size); 259 260 // try checking backwards 261 for (size_t offset = size; offset > 0; offset -= 26) { 262 REPORTER_ASSERT(reporter, stream->seek(offset - 26)); 263 REPORTER_ASSERT(reporter, stream->getPosition() == offset - 26); 264 REPORTER_ASSERT(reporter, stream->read(array, 26) == 26); 265 check_abcs(reporter, array, 26); 266 REPORTER_ASSERT(reporter, stream->getPosition() == offset); 267 } 268 } 269 270 // reader should contains an integral number of copies of gABC. 271 static void check_alphabet_buffer(skiatest::Reporter* reporter, const SkROBuffer* reader) { 272 size_t size = reader->size(); 273 REPORTER_ASSERT(reporter, size % 26 == 0); 274 275 SkAutoTMalloc<char> storage(size); 276 SkROBuffer::Iter iter(reader); 277 size_t offset = 0; 278 do { 279 SkASSERT(offset + iter.size() <= size); 280 memcpy(storage.get() + offset, iter.data(), iter.size()); 281 offset += iter.size(); 282 } while (iter.next()); 283 REPORTER_ASSERT(reporter, offset == size); 284 check_abcs(reporter, storage.get(), size); 285 } 286 287 DEF_TEST(RWBuffer, reporter) { 288 // Knowing that the default capacity is 4096, choose N large enough so we force it to use 289 // multiple buffers internally. 290 const int N = 1000; 291 SkROBuffer* readers[N]; 292 SkStream* streams[N]; 293 294 { 295 SkRWBuffer buffer; 296 for (int i = 0; i < N; ++i) { 297 if (0 == (i & 1)) { 298 buffer.append(gABC, 26); 299 } else { 300 memcpy(buffer.append(26), gABC, 26); 301 } 302 readers[i] = buffer.newRBufferSnapshot(); 303 streams[i] = buffer.newStreamSnapshot(); 304 } 305 REPORTER_ASSERT(reporter, N*26 == buffer.size()); 306 } 307 308 for (int i = 0; i < N; ++i) { 309 REPORTER_ASSERT(reporter, (i + 1) * 26U == readers[i]->size()); 310 check_alphabet_buffer(reporter, readers[i]); 311 check_alphabet_stream(reporter, streams[i]); 312 readers[i]->unref(); 313 delete streams[i]; 314 } 315 } 316 317 // Tests that it is safe to call SkROBuffer::Iter::size() when exhausted. 318 DEF_TEST(RWBuffer_size, r) { 319 SkRWBuffer buffer; 320 buffer.append(gABC, 26); 321 322 SkAutoTUnref<SkROBuffer> roBuffer(buffer.newRBufferSnapshot()); 323 SkROBuffer::Iter iter(roBuffer); 324 REPORTER_ASSERT(r, iter.data()); 325 REPORTER_ASSERT(r, iter.size() == 26); 326 327 // There is only one block in this buffer. 328 REPORTER_ASSERT(r, !iter.next()); 329 REPORTER_ASSERT(r, 0 == iter.size()); 330 } 331 332 // Tests that it is safe to destruct an SkRWBuffer without appending 333 // anything to it. 334 DEF_TEST(RWBuffer_noAppend, r) { 335 SkRWBuffer buffer; 336 REPORTER_ASSERT(r, 0 == buffer.size()); 337 } 338
