blob: b38bb9f90b2024ad6951d8b03294e8203bf70a3e [file] [log] [blame]
epoger@google.comec3ed6a2011-07-28 14:26:00 +00001/*
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 */
tfarina@chromium.orge4fafb12013-12-12 21:11:12 +00007
reed@android.comed673312009-02-27 16:24:51 +00008#include "SkRandom.h"
reed@android.comb00cd722010-04-16 20:35:47 +00009#include "SkRefCnt.h"
reed@android.comed673312009-02-27 16:24:51 +000010#include "SkTSearch.h"
11#include "SkTSort.h"
12#include "SkUtils.h"
tfarina@chromium.org8f6884a2014-01-24 20:56:26 +000013#include "Test.h"
reed@android.comed673312009-02-27 16:24:51 +000014
reed@android.comb00cd722010-04-16 20:35:47 +000015class RefClass : public SkRefCnt {
16public:
halcanary9d524f22016-03-29 09:03:52 -070017
robertphillips@google.coma22e2112012-08-16 14:58:06 +000018
reed@android.comb00cd722010-04-16 20:35:47 +000019 RefClass(int n) : fN(n) {}
20 int get() const { return fN; }
21
22private:
23 int fN;
robertphillips@google.coma22e2112012-08-16 14:58:06 +000024
25 typedef SkRefCnt INHERITED;
reed@android.comb00cd722010-04-16 20:35:47 +000026};
27
reed@google.coma67573e2011-02-25 18:10:29 +000028static void test_autounref(skiatest::Reporter* reporter) {
29 RefClass obj(0);
mtkleinbbb61d72014-11-24 13:09:39 -080030 REPORTER_ASSERT(reporter, obj.unique());
reed@google.coma67573e2011-02-25 18:10:29 +000031
32 SkAutoTUnref<RefClass> tmp(&obj);
33 REPORTER_ASSERT(reporter, &obj == tmp.get());
mtkleinbbb61d72014-11-24 13:09:39 -080034 REPORTER_ASSERT(reporter, obj.unique());
reed@google.coma67573e2011-02-25 18:10:29 +000035
mtklein18300a32016-03-16 13:53:35 -070036 REPORTER_ASSERT(reporter, &obj == tmp.release());
mtkleinbbb61d72014-11-24 13:09:39 -080037 REPORTER_ASSERT(reporter, obj.unique());
mtklein18300a32016-03-16 13:53:35 -070038 REPORTER_ASSERT(reporter, nullptr == tmp.release());
halcanary96fcdcc2015-08-27 07:41:13 -070039 REPORTER_ASSERT(reporter, nullptr == tmp.get());
reed@google.coma67573e2011-02-25 18:10:29 +000040
41 obj.ref();
mtkleinbbb61d72014-11-24 13:09:39 -080042 REPORTER_ASSERT(reporter, !obj.unique());
reed@google.coma67573e2011-02-25 18:10:29 +000043 {
44 SkAutoTUnref<RefClass> tmp2(&obj);
45 }
mtkleinbbb61d72014-11-24 13:09:39 -080046 REPORTER_ASSERT(reporter, obj.unique());
reed@google.coma67573e2011-02-25 18:10:29 +000047}
48
robertphillips@google.com4d376732013-07-12 18:44:23 +000049static void test_autostarray(skiatest::Reporter* reporter) {
50 RefClass obj0(0);
51 RefClass obj1(1);
mtkleinbbb61d72014-11-24 13:09:39 -080052 REPORTER_ASSERT(reporter, obj0.unique());
53 REPORTER_ASSERT(reporter, obj1.unique());
robertphillips@google.com4d376732013-07-12 18:44:23 +000054
55 {
bungeman733418f2014-07-17 12:17:55 -070056 SkAutoSTArray<2, SkAutoTUnref<RefClass> > tmp;
robertphillips@google.com4d376732013-07-12 18:44:23 +000057 REPORTER_ASSERT(reporter, 0 == tmp.count());
58
59 tmp.reset(0); // test out reset(0) when already at 0
60 tmp.reset(4); // this should force a new allocation
61 REPORTER_ASSERT(reporter, 4 == tmp.count());
bungeman733418f2014-07-17 12:17:55 -070062 tmp[0].reset(SkRef(&obj0));
63 tmp[1].reset(SkRef(&obj1));
mtkleinbbb61d72014-11-24 13:09:39 -080064 REPORTER_ASSERT(reporter, !obj0.unique());
65 REPORTER_ASSERT(reporter, !obj1.unique());
robertphillips@google.com4d376732013-07-12 18:44:23 +000066
67 // test out reset with data in the array (and a new allocation)
68 tmp.reset(0);
69 REPORTER_ASSERT(reporter, 0 == tmp.count());
mtkleinbbb61d72014-11-24 13:09:39 -080070 REPORTER_ASSERT(reporter, obj0.unique());
71 REPORTER_ASSERT(reporter, obj1.unique());
humper@google.com9c96d4b2013-07-14 01:44:59 +000072
robertphillips@google.com4d376732013-07-12 18:44:23 +000073 tmp.reset(2); // this should use the preexisting allocation
74 REPORTER_ASSERT(reporter, 2 == tmp.count());
bungeman733418f2014-07-17 12:17:55 -070075 tmp[0].reset(SkRef(&obj0));
76 tmp[1].reset(SkRef(&obj1));
robertphillips@google.com4d376732013-07-12 18:44:23 +000077 }
78
79 // test out destructor with data in the array (and using existing allocation)
mtkleinbbb61d72014-11-24 13:09:39 -080080 REPORTER_ASSERT(reporter, obj0.unique());
81 REPORTER_ASSERT(reporter, obj1.unique());
robertphillips@google.com4d376732013-07-12 18:44:23 +000082
83 {
84 // test out allocating ctor (this should allocate new memory)
bungeman733418f2014-07-17 12:17:55 -070085 SkAutoSTArray<2, SkAutoTUnref<RefClass> > tmp(4);
robertphillips@google.com4d376732013-07-12 18:44:23 +000086 REPORTER_ASSERT(reporter, 4 == tmp.count());
87
bungeman733418f2014-07-17 12:17:55 -070088 tmp[0].reset(SkRef(&obj0));
89 tmp[1].reset(SkRef(&obj1));
mtkleinbbb61d72014-11-24 13:09:39 -080090 REPORTER_ASSERT(reporter, !obj0.unique());
91 REPORTER_ASSERT(reporter, !obj1.unique());
robertphillips@google.com4d376732013-07-12 18:44:23 +000092
93 // Test out resut with data in the array and malloced storage
94 tmp.reset(0);
mtkleinbbb61d72014-11-24 13:09:39 -080095 REPORTER_ASSERT(reporter, obj0.unique());
96 REPORTER_ASSERT(reporter, obj1.unique());
robertphillips@google.com4d376732013-07-12 18:44:23 +000097
98 tmp.reset(2); // this should use the preexisting storage
bungeman733418f2014-07-17 12:17:55 -070099 tmp[0].reset(SkRef(&obj0));
100 tmp[1].reset(SkRef(&obj1));
mtkleinbbb61d72014-11-24 13:09:39 -0800101 REPORTER_ASSERT(reporter, !obj0.unique());
102 REPORTER_ASSERT(reporter, !obj1.unique());
robertphillips@google.com4d376732013-07-12 18:44:23 +0000103
104 tmp.reset(4); // this should force a new malloc
mtkleinbbb61d72014-11-24 13:09:39 -0800105 REPORTER_ASSERT(reporter, obj0.unique());
106 REPORTER_ASSERT(reporter, obj1.unique());
robertphillips@google.com4d376732013-07-12 18:44:23 +0000107
bungeman733418f2014-07-17 12:17:55 -0700108 tmp[0].reset(SkRef(&obj0));
109 tmp[1].reset(SkRef(&obj1));
mtkleinbbb61d72014-11-24 13:09:39 -0800110 REPORTER_ASSERT(reporter, !obj0.unique());
111 REPORTER_ASSERT(reporter, !obj1.unique());
robertphillips@google.com4d376732013-07-12 18:44:23 +0000112 }
113
mtkleinbbb61d72014-11-24 13:09:39 -0800114 REPORTER_ASSERT(reporter, obj0.unique());
115 REPORTER_ASSERT(reporter, obj1.unique());
robertphillips@google.com4d376732013-07-12 18:44:23 +0000116}
117
epoger@google.combcc56832011-05-20 17:35:46 +0000118/////////////////////////////////////////////////////////////////////////////
reed@android.comb00cd722010-04-16 20:35:47 +0000119
reed@android.comed673312009-02-27 16:24:51 +0000120#define kSEARCH_COUNT 91
121
122static void test_search(skiatest::Reporter* reporter) {
123 int i, array[kSEARCH_COUNT];
commit-bot@chromium.orge0e7cfe2013-09-09 20:09:12 +0000124 SkRandom rand;
reed@android.comed673312009-02-27 16:24:51 +0000125
126 for (i = 0; i < kSEARCH_COUNT; i++) {
127 array[i] = rand.nextS();
128 }
129
130 SkTHeapSort<int>(array, kSEARCH_COUNT);
131 // make sure we got sorted properly
132 for (i = 1; i < kSEARCH_COUNT; i++) {
133 REPORTER_ASSERT(reporter, array[i-1] <= array[i]);
134 }
135
136 // make sure we can find all of our values
137 for (i = 0; i < kSEARCH_COUNT; i++) {
138 int index = SkTSearch<int>(array, kSEARCH_COUNT, array[i], sizeof(int));
139 REPORTER_ASSERT(reporter, index == i);
140 }
141
142 // make sure that random values are either found, or the correct
143 // insertion index is returned
144 for (i = 0; i < 10000; i++) {
145 int value = rand.nextS();
146 int index = SkTSearch<int>(array, kSEARCH_COUNT, value, sizeof(int));
147
148 if (index >= 0) {
149 REPORTER_ASSERT(reporter,
150 index < kSEARCH_COUNT && array[index] == value);
151 } else {
152 index = ~index;
153 REPORTER_ASSERT(reporter, index <= kSEARCH_COUNT);
154 if (index < kSEARCH_COUNT) {
155 REPORTER_ASSERT(reporter, value < array[index]);
156 if (index > 0) {
157 REPORTER_ASSERT(reporter, value > array[index - 1]);
158 }
159 } else {
160 // we should append the new value
161 REPORTER_ASSERT(reporter, value > array[kSEARCH_COUNT - 1]);
162 }
163 }
164 }
165}
166
167static void test_utf16(skiatest::Reporter* reporter) {
168 static const SkUnichar gUni[] = {
169 0x10000, 0x18080, 0x20202, 0xFFFFF, 0x101234
170 };
reed@android.com80e39a72009-04-02 16:59:40 +0000171
reed@android.comed673312009-02-27 16:24:51 +0000172 uint16_t buf[2];
reed@android.com80e39a72009-04-02 16:59:40 +0000173
reed@android.comed673312009-02-27 16:24:51 +0000174 for (size_t i = 0; i < SK_ARRAY_COUNT(gUni); i++) {
175 size_t count = SkUTF16_FromUnichar(gUni[i], buf);
176 REPORTER_ASSERT(reporter, count == 2);
177 size_t count2 = SkUTF16_CountUnichars(buf, 2);
178 REPORTER_ASSERT(reporter, count2 == 1);
179 const uint16_t* ptr = buf;
180 SkUnichar c = SkUTF16_NextUnichar(&ptr);
181 REPORTER_ASSERT(reporter, c == gUni[i]);
182 REPORTER_ASSERT(reporter, ptr - buf == 2);
183 }
184}
185
tfarina@chromium.orge4fafb12013-12-12 21:11:12 +0000186DEF_TEST(Utils, reporter) {
reed@android.comed673312009-02-27 16:24:51 +0000187 static const struct {
188 const char* fUtf8;
189 SkUnichar fUni;
190 } gTest[] = {
191 { "a", 'a' },
192 { "\x7f", 0x7f },
193 { "\xC2\x80", 0x80 },
194 { "\xC3\x83", (3 << 6) | 3 },
195 { "\xDF\xBF", 0x7ff },
196 { "\xE0\xA0\x80", 0x800 },
197 { "\xE0\xB0\xB8", 0xC38 },
198 { "\xE3\x83\x83", (3 << 12) | (3 << 6) | 3 },
199 { "\xEF\xBF\xBF", 0xFFFF },
200 { "\xF0\x90\x80\x80", 0x10000 },
201 { "\xF3\x83\x83\x83", (3 << 18) | (3 << 12) | (3 << 6) | 3 }
202 };
203
204 for (size_t i = 0; i < SK_ARRAY_COUNT(gTest); i++) {
205 const char* p = gTest[i].fUtf8;
206 int n = SkUTF8_CountUnichars(p);
207 SkUnichar u0 = SkUTF8_ToUnichar(gTest[i].fUtf8);
208 SkUnichar u1 = SkUTF8_NextUnichar(&p);
209
210 REPORTER_ASSERT(reporter, n == 1);
211 REPORTER_ASSERT(reporter, u0 == u1);
212 REPORTER_ASSERT(reporter, u0 == gTest[i].fUni);
213 REPORTER_ASSERT(reporter,
214 p - gTest[i].fUtf8 == (int)strlen(gTest[i].fUtf8));
215 }
reed@android.com80e39a72009-04-02 16:59:40 +0000216
reed@android.comed673312009-02-27 16:24:51 +0000217 test_utf16(reporter);
218 test_search(reporter);
reed@google.coma67573e2011-02-25 18:10:29 +0000219 test_autounref(reporter);
robertphillips@google.com4d376732013-07-12 18:44:23 +0000220 test_autostarray(reporter);
reed@android.comed673312009-02-27 16:24:51 +0000221}