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
test_is_equal(skiatest::Reporter * reporter,const SkDataTable * a,const SkDataTable * b)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
test_datatable_is_empty(skiatest::Reporter * reporter,SkDataTable * table)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
test_emptytable(skiatest::Reporter * reporter)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
test_simpletable(skiatest::Reporter * reporter)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
test_vartable(skiatest::Reporter * reporter)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
test_tablebuilder(skiatest::Reporter * reporter)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
test_globaltable(skiatest::Reporter * reporter)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
DEF_TEST(DataTable,reporter)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
delete_int_proc(const void * ptr,void * context)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
assert_len(skiatest::Reporter * reporter,SkData * ref,size_t len)152 static void assert_len(skiatest::Reporter* reporter, SkData* ref, size_t len) {
153 REPORTER_ASSERT(reporter, ref->size() == len);
154 }
155
assert_data(skiatest::Reporter * reporter,SkData * ref,const void * data,size_t len)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
test_cstring(skiatest::Reporter * reporter)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
test_files(skiatest::Reporter * reporter)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
DEF_TEST(Data,reporter)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
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);
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.
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());
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.
check_alphabet_buffer(skiatest::Reporter * reporter,const SkROBuffer * reader)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
DEF_TEST(RWBuffer,reporter)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.
DEF_TEST(RWBuffer_size,r)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.
DEF_TEST(RWBuffer_noAppend,r)334 DEF_TEST(RWBuffer_noAppend, r) {
335 SkRWBuffer buffer;
336 REPORTER_ASSERT(r, 0 == buffer.size());
337 }
338