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(NULL, NULL, 0));
37 SkAutoTUnref<SkDataTable> table2(SkDataTable::NewCopyArray(NULL, 0, 0));
38 SkAutoTUnref<SkDataTable> table3(SkDataTable::NewArrayProc(NULL, 0, 0,
39 NULL, NULL));
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, NULL, NULL));
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,size_t len,void * context)146 static void delete_int_proc(const void* ptr, size_t len, 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(NULL));
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::Test::GetTmpDir();
178 if (tmpDir.isEmpty()) {
179 return;
180 }
181
182 SkString path = SkOSPath::SkPathJoin(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 SkFILE* file = sk_fopen(path.c_str(), kRead_SkFILE_Flag);
195 SkAutoTUnref<SkData> r1(SkData::NewFromFILE(file));
196 REPORTER_ASSERT(reporter, r1.get() != NULL);
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() != NULL);
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