tests/UtilsTest.cpp - platform/external/skia - Gitiles

 /*
  * 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 * sizeof(uint16_t));
         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_CountUnichars(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)));
     }

 }
	/*
	* 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 * sizeof(uint16_t));
	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_CountUnichars(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)));
	}

	}