OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2011 Google Inc. | 2 * Copyright 2011 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkData.h" | 8 #include "SkData.h" |
9 #include "SkDataTable.h" | 9 #include "SkDataTable.h" |
10 #include "SkOSFile.h" | 10 #include "SkOSFile.h" |
(...skipping 227 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
238 | 238 |
239 const char gABC[] = "abcdefghijklmnopqrstuvwxyz"; | 239 const char gABC[] = "abcdefghijklmnopqrstuvwxyz"; |
240 | 240 |
241 static void check_abcs(skiatest::Reporter* reporter, const char buffer[], size_t
size) { | 241 static void check_abcs(skiatest::Reporter* reporter, const char buffer[], size_t
size) { |
242 REPORTER_ASSERT(reporter, size % 26 == 0); | 242 REPORTER_ASSERT(reporter, size % 26 == 0); |
243 for (size_t offset = 0; offset < size; offset += 26) { | 243 for (size_t offset = 0; offset < size; offset += 26) { |
244 REPORTER_ASSERT(reporter, !memcmp(&buffer[offset], gABC, 26)); | 244 REPORTER_ASSERT(reporter, !memcmp(&buffer[offset], gABC, 26)); |
245 } | 245 } |
246 } | 246 } |
247 | 247 |
248 // stream should contains an integral number of copies of gABC. | 248 // stream should contain an integral number of copies of gABC. |
249 static void check_alphabet_stream(skiatest::Reporter* reporter, SkStream* stream
) { | 249 static void check_alphabet_stream(skiatest::Reporter* reporter, SkStream* stream
) { |
250 REPORTER_ASSERT(reporter, stream->hasLength()); | 250 REPORTER_ASSERT(reporter, stream->hasLength()); |
251 size_t size = stream->getLength(); | 251 size_t size = stream->getLength(); |
252 REPORTER_ASSERT(reporter, size % 26 == 0); | 252 REPORTER_ASSERT(reporter, size % 26 == 0); |
253 | 253 |
254 SkAutoTMalloc<char> storage(size); | 254 SkAutoTMalloc<char> storage(size); |
255 char* array = storage.get(); | 255 char* array = storage.get(); |
256 size_t bytesRead = stream->read(array, size); | 256 size_t bytesRead = stream->read(array, size); |
257 REPORTER_ASSERT(reporter, bytesRead == size); | 257 REPORTER_ASSERT(reporter, bytesRead == size); |
258 check_abcs(reporter, array, size); | 258 check_abcs(reporter, array, size); |
(...skipping 18 matching lines...) Expand all Loading... |
277 size_t offset = 0; | 277 size_t offset = 0; |
278 do { | 278 do { |
279 SkASSERT(offset + iter.size() <= size); | 279 SkASSERT(offset + iter.size() <= size); |
280 memcpy(storage.get() + offset, iter.data(), iter.size()); | 280 memcpy(storage.get() + offset, iter.data(), iter.size()); |
281 offset += iter.size(); | 281 offset += iter.size(); |
282 } while (iter.next()); | 282 } while (iter.next()); |
283 REPORTER_ASSERT(reporter, offset == size); | 283 REPORTER_ASSERT(reporter, offset == size); |
284 check_abcs(reporter, storage.get(), size); | 284 check_abcs(reporter, storage.get(), size); |
285 } | 285 } |
286 | 286 |
| 287 #include "SkTaskGroup.h" |
| 288 |
287 DEF_TEST(RWBuffer, reporter) { | 289 DEF_TEST(RWBuffer, reporter) { |
288 // Knowing that the default capacity is 4096, choose N large enough so we fo
rce it to use | 290 // Knowing that the default capacity is 4096, choose N large enough so we fo
rce it to use |
289 // multiple buffers internally. | 291 // multiple buffers internally. |
290 const int N = 1000; | 292 const int N = 1000; |
291 SkROBuffer* readers[N]; | 293 SkROBuffer* readers[N]; |
292 SkStream* streams[N]; | 294 SkStream* streams[N]; |
293 | 295 |
294 { | 296 { |
295 SkRWBuffer buffer; | 297 SkRWBuffer buffer; |
296 for (int i = 0; i < N; ++i) { | 298 for (int i = 0; i < N; ++i) { |
297 buffer.append(gABC, 26); | 299 buffer.append(gABC, 26); |
298 readers[i] = buffer.newRBufferSnapshot(); | 300 readers[i] = buffer.newRBufferSnapshot(); |
299 streams[i] = buffer.newStreamSnapshot(); | 301 streams[i] = buffer.newStreamSnapshot(); |
300 } | 302 } |
301 REPORTER_ASSERT(reporter, N*26 == buffer.size()); | 303 REPORTER_ASSERT(reporter, N*26 == buffer.size()); |
302 } | 304 } |
303 | 305 |
| 306 // Verify that although the SkRWBuffer's destructor has run, the readers are
still valid. |
304 for (int i = 0; i < N; ++i) { | 307 for (int i = 0; i < N; ++i) { |
305 REPORTER_ASSERT(reporter, (i + 1) * 26U == readers[i]->size()); | 308 REPORTER_ASSERT(reporter, (i + 1) * 26U == readers[i]->size()); |
306 check_alphabet_buffer(reporter, readers[i]); | 309 check_alphabet_buffer(reporter, readers[i]); |
307 check_alphabet_stream(reporter, streams[i]); | 310 check_alphabet_stream(reporter, streams[i]); |
308 readers[i]->unref(); | 311 readers[i]->unref(); |
309 delete streams[i]; | 312 delete streams[i]; |
310 } | 313 } |
311 } | 314 } |
312 | 315 |
| 316 DEF_TEST(RWBuffer_threaded, reporter) { |
| 317 // Knowing that the default capacity is 4096, choose N large enough so we fo
rce it to use |
| 318 // multiple buffers internally. |
| 319 const int N = 1000; |
| 320 SkTaskGroup tasks; |
| 321 SkRWBuffer buffer; |
| 322 for (int i = 0; i < N; ++i) { |
| 323 buffer.append(gABC, 26); |
| 324 sk_sp<SkROBuffer> reader = sk_sp<SkROBuffer>(buffer.newRBufferSnapshot()
); |
| 325 SkStream* stream = buffer.newStreamSnapshot(); |
| 326 REPORTER_ASSERT(reporter, reader->size() == buffer.size()); |
| 327 REPORTER_ASSERT(reporter, stream->getLength() == buffer.size()); |
| 328 |
| 329 // reader's copy constructor will ref the SkROBuffer, which will be unre
ffed |
| 330 // when the task ends. |
| 331 // Ownership of stream is passed to the task, which will delete it. |
| 332 tasks.add([reporter, i, reader, stream] { |
| 333 REPORTER_ASSERT(reporter, (i + 1) * 26U == reader->size()); |
| 334 REPORTER_ASSERT(reporter, stream->getLength() == reader->size()); |
| 335 check_alphabet_buffer(reporter, reader.get()); |
| 336 check_alphabet_stream(reporter, stream); |
| 337 REPORTER_ASSERT(reporter, stream->rewind()); |
| 338 delete stream; |
| 339 }); |
| 340 } |
| 341 REPORTER_ASSERT(reporter, N*26 == buffer.size()); |
| 342 tasks.wait(); |
| 343 } |
| 344 |
313 // Tests that it is safe to call SkROBuffer::Iter::size() when exhausted. | 345 // Tests that it is safe to call SkROBuffer::Iter::size() when exhausted. |
314 DEF_TEST(RWBuffer_size, r) { | 346 DEF_TEST(RWBuffer_size, r) { |
315 SkRWBuffer buffer; | 347 SkRWBuffer buffer; |
316 buffer.append(gABC, 26); | 348 buffer.append(gABC, 26); |
317 | 349 |
318 SkAutoTUnref<SkROBuffer> roBuffer(buffer.newRBufferSnapshot()); | 350 SkAutoTUnref<SkROBuffer> roBuffer(buffer.newRBufferSnapshot()); |
319 SkROBuffer::Iter iter(roBuffer); | 351 SkROBuffer::Iter iter(roBuffer); |
320 REPORTER_ASSERT(r, iter.data()); | 352 REPORTER_ASSERT(r, iter.data()); |
321 REPORTER_ASSERT(r, iter.size() == 26); | 353 REPORTER_ASSERT(r, iter.size() == 26); |
322 | 354 |
323 // There is only one block in this buffer. | 355 // There is only one block in this buffer. |
324 REPORTER_ASSERT(r, !iter.next()); | 356 REPORTER_ASSERT(r, !iter.next()); |
325 REPORTER_ASSERT(r, 0 == iter.size()); | 357 REPORTER_ASSERT(r, 0 == iter.size()); |
326 } | 358 } |
327 | 359 |
328 // Tests that it is safe to destruct an SkRWBuffer without appending | 360 // Tests that operations (including the destructor) are safe on an SkRWBuffer |
329 // anything to it. | 361 // without any data appended. |
330 DEF_TEST(RWBuffer_noAppend, r) { | 362 DEF_TEST(RWBuffer_noAppend, r) { |
331 SkRWBuffer buffer; | 363 SkRWBuffer buffer; |
332 REPORTER_ASSERT(r, 0 == buffer.size()); | 364 REPORTER_ASSERT(r, 0 == buffer.size()); |
| 365 |
| 366 sk_sp<SkROBuffer> roBuffer = sk_sp<SkROBuffer>(buffer.newRBufferSnapshot()); |
| 367 REPORTER_ASSERT(r, roBuffer); |
| 368 if (roBuffer) { |
| 369 REPORTER_ASSERT(r, roBuffer->size() == 0); |
| 370 SkROBuffer::Iter iter(roBuffer.get()); |
| 371 REPORTER_ASSERT(r, iter.size() == 0); |
| 372 REPORTER_ASSERT(r, !iter.data()); |
| 373 REPORTER_ASSERT(r, !iter.next()); |
| 374 } |
| 375 |
| 376 SkAutoTDelete<SkStream> stream(buffer.newStreamSnapshot()); |
| 377 REPORTER_ASSERT(r, stream); |
| 378 if (stream) { |
| 379 REPORTER_ASSERT(r, stream->hasLength()); |
| 380 REPORTER_ASSERT(r, stream->getLength() == 0); |
| 381 REPORTER_ASSERT(r, stream->skip(10) == 0); |
| 382 } |
333 } | 383 } |
OLD | NEW |