d1c8e56423
Theory: We will accept blobs of data as utf-8 text without validation, but when it comes time to process it: count code poits or convert to code points, be careful to check for errors. TODO: SkTypeface::charsToGlyphs() needs to take a length. Change-Id: Id8110ab43dbffce96faffdda1e0bdaa39cad40e4 Reviewed-on: https://skia-review.googlesource.com/6849 Commit-Queue: Hal Canary <halcanary@google.com> Reviewed-by: Herb Derby <herb@google.com>
283 lines
9.6 KiB
C++
283 lines
9.6 KiB
C++
/*
|
|
* Copyright 2011 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "SkRandom.h"
|
|
#include "SkRefCnt.h"
|
|
#include "SkTSearch.h"
|
|
#include "SkTSort.h"
|
|
#include "SkUtils.h"
|
|
#include "Test.h"
|
|
|
|
class RefClass : public SkRefCnt {
|
|
public:
|
|
|
|
|
|
RefClass(int n) : fN(n) {}
|
|
int get() const { return fN; }
|
|
|
|
private:
|
|
int fN;
|
|
|
|
typedef SkRefCnt INHERITED;
|
|
};
|
|
|
|
static void test_autounref(skiatest::Reporter* reporter) {
|
|
RefClass obj(0);
|
|
REPORTER_ASSERT(reporter, obj.unique());
|
|
|
|
sk_sp<RefClass> tmp(&obj);
|
|
REPORTER_ASSERT(reporter, &obj == tmp.get());
|
|
REPORTER_ASSERT(reporter, obj.unique());
|
|
|
|
REPORTER_ASSERT(reporter, &obj == tmp.release());
|
|
REPORTER_ASSERT(reporter, obj.unique());
|
|
REPORTER_ASSERT(reporter, nullptr == tmp.release());
|
|
REPORTER_ASSERT(reporter, nullptr == tmp.get());
|
|
|
|
obj.ref();
|
|
REPORTER_ASSERT(reporter, !obj.unique());
|
|
{
|
|
sk_sp<RefClass> tmp2(&obj);
|
|
}
|
|
REPORTER_ASSERT(reporter, obj.unique());
|
|
}
|
|
|
|
static void test_autostarray(skiatest::Reporter* reporter) {
|
|
RefClass obj0(0);
|
|
RefClass obj1(1);
|
|
REPORTER_ASSERT(reporter, obj0.unique());
|
|
REPORTER_ASSERT(reporter, obj1.unique());
|
|
|
|
{
|
|
SkAutoSTArray<2, sk_sp<RefClass> > tmp;
|
|
REPORTER_ASSERT(reporter, 0 == tmp.count());
|
|
|
|
tmp.reset(0); // test out reset(0) when already at 0
|
|
tmp.reset(4); // this should force a new allocation
|
|
REPORTER_ASSERT(reporter, 4 == tmp.count());
|
|
tmp[0].reset(SkRef(&obj0));
|
|
tmp[1].reset(SkRef(&obj1));
|
|
REPORTER_ASSERT(reporter, !obj0.unique());
|
|
REPORTER_ASSERT(reporter, !obj1.unique());
|
|
|
|
// test out reset with data in the array (and a new allocation)
|
|
tmp.reset(0);
|
|
REPORTER_ASSERT(reporter, 0 == tmp.count());
|
|
REPORTER_ASSERT(reporter, obj0.unique());
|
|
REPORTER_ASSERT(reporter, obj1.unique());
|
|
|
|
tmp.reset(2); // this should use the preexisting allocation
|
|
REPORTER_ASSERT(reporter, 2 == tmp.count());
|
|
tmp[0].reset(SkRef(&obj0));
|
|
tmp[1].reset(SkRef(&obj1));
|
|
}
|
|
|
|
// test out destructor with data in the array (and using existing allocation)
|
|
REPORTER_ASSERT(reporter, obj0.unique());
|
|
REPORTER_ASSERT(reporter, obj1.unique());
|
|
|
|
{
|
|
// test out allocating ctor (this should allocate new memory)
|
|
SkAutoSTArray<2, sk_sp<RefClass> > tmp(4);
|
|
REPORTER_ASSERT(reporter, 4 == tmp.count());
|
|
|
|
tmp[0].reset(SkRef(&obj0));
|
|
tmp[1].reset(SkRef(&obj1));
|
|
REPORTER_ASSERT(reporter, !obj0.unique());
|
|
REPORTER_ASSERT(reporter, !obj1.unique());
|
|
|
|
// Test out resut with data in the array and malloced storage
|
|
tmp.reset(0);
|
|
REPORTER_ASSERT(reporter, obj0.unique());
|
|
REPORTER_ASSERT(reporter, obj1.unique());
|
|
|
|
tmp.reset(2); // this should use the preexisting storage
|
|
tmp[0].reset(SkRef(&obj0));
|
|
tmp[1].reset(SkRef(&obj1));
|
|
REPORTER_ASSERT(reporter, !obj0.unique());
|
|
REPORTER_ASSERT(reporter, !obj1.unique());
|
|
|
|
tmp.reset(4); // this should force a new malloc
|
|
REPORTER_ASSERT(reporter, obj0.unique());
|
|
REPORTER_ASSERT(reporter, obj1.unique());
|
|
|
|
tmp[0].reset(SkRef(&obj0));
|
|
tmp[1].reset(SkRef(&obj1));
|
|
REPORTER_ASSERT(reporter, !obj0.unique());
|
|
REPORTER_ASSERT(reporter, !obj1.unique());
|
|
}
|
|
|
|
REPORTER_ASSERT(reporter, obj0.unique());
|
|
REPORTER_ASSERT(reporter, obj1.unique());
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define kSEARCH_COUNT 91
|
|
|
|
static void test_search(skiatest::Reporter* reporter) {
|
|
int i, array[kSEARCH_COUNT];
|
|
SkRandom rand;
|
|
|
|
for (i = 0; i < kSEARCH_COUNT; i++) {
|
|
array[i] = rand.nextS();
|
|
}
|
|
|
|
SkTHeapSort<int>(array, kSEARCH_COUNT);
|
|
// make sure we got sorted properly
|
|
for (i = 1; i < kSEARCH_COUNT; i++) {
|
|
REPORTER_ASSERT(reporter, array[i-1] <= array[i]);
|
|
}
|
|
|
|
// make sure we can find all of our values
|
|
for (i = 0; i < kSEARCH_COUNT; i++) {
|
|
int index = SkTSearch<int>(array, kSEARCH_COUNT, array[i], sizeof(int));
|
|
REPORTER_ASSERT(reporter, index == i);
|
|
}
|
|
|
|
// make sure that random values are either found, or the correct
|
|
// insertion index is returned
|
|
for (i = 0; i < 10000; i++) {
|
|
int value = rand.nextS();
|
|
int index = SkTSearch<int>(array, kSEARCH_COUNT, value, sizeof(int));
|
|
|
|
if (index >= 0) {
|
|
REPORTER_ASSERT(reporter,
|
|
index < kSEARCH_COUNT && array[index] == value);
|
|
} else {
|
|
index = ~index;
|
|
REPORTER_ASSERT(reporter, index <= kSEARCH_COUNT);
|
|
if (index < kSEARCH_COUNT) {
|
|
REPORTER_ASSERT(reporter, value < array[index]);
|
|
if (index > 0) {
|
|
REPORTER_ASSERT(reporter, value > array[index - 1]);
|
|
}
|
|
} else {
|
|
// we should append the new value
|
|
REPORTER_ASSERT(reporter, value > array[kSEARCH_COUNT - 1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void test_utf16(skiatest::Reporter* reporter) {
|
|
static const SkUnichar gUni[] = {
|
|
0x10000, 0x18080, 0x20202, 0xFFFFF, 0x101234
|
|
};
|
|
|
|
uint16_t buf[2];
|
|
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(gUni); i++) {
|
|
size_t count = SkUTF16_FromUnichar(gUni[i], buf);
|
|
REPORTER_ASSERT(reporter, count == 2);
|
|
size_t count2 = SkUTF16_CountUnichars(buf, 2);
|
|
REPORTER_ASSERT(reporter, count2 == 1);
|
|
const uint16_t* ptr = buf;
|
|
SkUnichar c = SkUTF16_NextUnichar(&ptr);
|
|
REPORTER_ASSERT(reporter, c == gUni[i]);
|
|
REPORTER_ASSERT(reporter, ptr - buf == 2);
|
|
}
|
|
}
|
|
|
|
DEF_TEST(Utils, reporter) {
|
|
static const struct {
|
|
const char* fUtf8;
|
|
SkUnichar fUni;
|
|
} gTest[] = {
|
|
{ "a", 'a' },
|
|
{ "\x7f", 0x7f },
|
|
{ "\xC2\x80", 0x80 },
|
|
{ "\xC3\x83", (3 << 6) | 3 },
|
|
{ "\xDF\xBF", 0x7ff },
|
|
{ "\xE0\xA0\x80", 0x800 },
|
|
{ "\xE0\xB0\xB8", 0xC38 },
|
|
{ "\xE3\x83\x83", (3 << 12) | (3 << 6) | 3 },
|
|
{ "\xEF\xBF\xBF", 0xFFFF },
|
|
{ "\xF0\x90\x80\x80", 0x10000 },
|
|
{ "\xF3\x83\x83\x83", (3 << 18) | (3 << 12) | (3 << 6) | 3 }
|
|
};
|
|
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(gTest); i++) {
|
|
const char* p = gTest[i].fUtf8;
|
|
int n = SkUTF8_CountUnichars(p);
|
|
SkUnichar u0 = SkUTF8_ToUnichar(gTest[i].fUtf8);
|
|
SkUnichar u1 = SkUTF8_NextUnichar(&p);
|
|
|
|
REPORTER_ASSERT(reporter, n == 1);
|
|
REPORTER_ASSERT(reporter, u0 == u1);
|
|
REPORTER_ASSERT(reporter, u0 == gTest[i].fUni);
|
|
REPORTER_ASSERT(reporter,
|
|
p - gTest[i].fUtf8 == (int)strlen(gTest[i].fUtf8));
|
|
}
|
|
|
|
test_utf16(reporter);
|
|
test_search(reporter);
|
|
test_autounref(reporter);
|
|
test_autostarray(reporter);
|
|
}
|
|
|
|
#define ASCII_BYTE "X"
|
|
#define CONTINUATION_BYTE "\x80"
|
|
#define LEADING_TWO_BYTE "\xC4"
|
|
#define LEADING_THREE_BYTE "\xE0"
|
|
#define LEADING_FOUR_BYTE "\xF0"
|
|
#define INVALID_BYTE "\xFC"
|
|
static bool valid_utf8(const char* p, size_t l) {
|
|
return SkUTF8_CountUnicharsWithError(p, l) >= 0;
|
|
}
|
|
DEF_TEST(Utils_UTF8_ValidLength, r) {
|
|
const char* goodTestcases[] = {
|
|
"",
|
|
ASCII_BYTE,
|
|
ASCII_BYTE ASCII_BYTE,
|
|
LEADING_TWO_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE LEADING_TWO_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE ASCII_BYTE LEADING_TWO_BYTE CONTINUATION_BYTE,
|
|
LEADING_THREE_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE LEADING_THREE_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE ASCII_BYTE LEADING_THREE_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
LEADING_FOUR_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE LEADING_FOUR_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE ASCII_BYTE LEADING_FOUR_BYTE CONTINUATION_BYTE CONTINUATION_BYTE
|
|
CONTINUATION_BYTE,
|
|
};
|
|
for (const char* testcase : goodTestcases) {
|
|
REPORTER_ASSERT(r, valid_utf8(testcase, strlen(testcase)));
|
|
}
|
|
const char* badTestcases[] = {
|
|
INVALID_BYTE,
|
|
INVALID_BYTE CONTINUATION_BYTE,
|
|
INVALID_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
INVALID_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
LEADING_TWO_BYTE,
|
|
CONTINUATION_BYTE,
|
|
CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
LEADING_THREE_BYTE CONTINUATION_BYTE,
|
|
CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
LEADING_FOUR_BYTE CONTINUATION_BYTE,
|
|
CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
|
|
ASCII_BYTE INVALID_BYTE,
|
|
ASCII_BYTE INVALID_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE INVALID_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE INVALID_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE LEADING_TWO_BYTE,
|
|
ASCII_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE LEADING_THREE_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE LEADING_FOUR_BYTE CONTINUATION_BYTE,
|
|
ASCII_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE CONTINUATION_BYTE,
|
|
|
|
// LEADING_FOUR_BYTE LEADING_TWO_BYTE CONTINUATION_BYTE,
|
|
};
|
|
for (const char* testcase : badTestcases) {
|
|
REPORTER_ASSERT(r, !valid_utf8(testcase, strlen(testcase)));
|
|
}
|
|
|
|
}
|