android/skin/rect_unittest.cpp - platform/external/qemu.git - Git at Google

 /* Copyright (C) 2014 The Android Open Source Project
 **
 ** This software is licensed under the terms of the GNU General Public
 ** License version 2, as published by the Free Software Foundation, and
 ** may be copied, distributed, and modified under those terms.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 */
 #include "android/skin/rect.h"

 #include <gtest/gtest.h>

 #define ARRAYLEN(x)  (sizeof(x)/sizeof((x)[0]))

 namespace android_skin {

 TEST(rect, skin_pos_rotate) {
     static const struct {
         SkinPos expected;
         SkinPos pos;
         SkinRotation rotation;
     } kData[] = {
         { { 0, 0 }, { 0, 0 }, SKIN_ROTATION_0 },
         { { 0, 0 }, { 0, 0 }, SKIN_ROTATION_90 },
         { { 0, 0 }, { 0, 0 }, SKIN_ROTATION_180 },
         { { 0, 0 }, { 0, 0 }, SKIN_ROTATION_270 },

         { { 100, 0 }, { 100, 0 }, SKIN_ROTATION_0 },
         { { 0, 100 }, { 100, 0 }, SKIN_ROTATION_90 },
         { { -100, 0 }, { 100, 0 }, SKIN_ROTATION_180 },
         { { 0, -100 }, { 100, 0 }, SKIN_ROTATION_270 },

         { { 0, 100 }, { 0, 100 }, SKIN_ROTATION_0 },
         { { -100, 0 }, { 0, 100 }, SKIN_ROTATION_90 },
         { { 0, -100 }, { 0, 100 }, SKIN_ROTATION_180 },
         { { 100, 0 }, { 0, 100 }, SKIN_ROTATION_270 },

         { { -100, 0 }, { -100, 0 }, SKIN_ROTATION_0 },
         { { 0, -100 }, { -100, 0 }, SKIN_ROTATION_90 },
         { { 100, 0 }, { -100, 0 }, SKIN_ROTATION_180 },
         { { 0, 100 }, { -100, 0 }, SKIN_ROTATION_270 },

         { { 0, -100 }, { 0, -100 }, SKIN_ROTATION_0 },
         { { 100, 0 }, { 0, -100 }, SKIN_ROTATION_90 },
         { { 0, 100 }, { 0, -100 }, SKIN_ROTATION_180 },
         { { -100, 0 }, { 0, -100 }, SKIN_ROTATION_270 },

         { { 100, 200 }, { 100, 200 }, SKIN_ROTATION_0 },
         { { -200, 100 }, { 100, 200 }, SKIN_ROTATION_90 },
         { { -100, -200 }, { 100, 200 }, SKIN_ROTATION_180 },
         { { 200, -100 }, { 100, 200 }, SKIN_ROTATION_270 },
     };
     const size_t kDataLen = ARRAYLEN(kData);
     for (size_t n = 0; n < kDataLen; ++n) {
         SkinPos result = kData[n].pos;
         // Note: this checks that the function works when |src == dst|.
         skin_pos_rotate(&result, &result, kData[n].rotation);
         EXPECT_EQ(kData[n].expected.x, result.x) << "#" << n;
         EXPECT_EQ(kData[n].expected.y, result.y) << "#" << n;
     }
 }

 TEST(rect, skin_size_contains) {
     static const struct {
         bool expected;
         SkinSize size;
         int x;
         int y;
     } kData[] = {
         { false, { 0, 0 }, 0, 0 },
         { true, { 1, 1 }, 0, 0 },
         { false, { 1, 1 }, 1, 1 },
         { true, { 10, 20 }, 0, 0 },
         { false, { 10, 20 }, 10, 0 },
         { false, { 10, 20 }, 0, 20 },
         { false, { 10, 20 }, 10, 20 },
         { true, { 10, 20 }, 9, 19 },
     };
     const size_t kDataLen = ARRAYLEN(kData);
     for (size_t n = 0; n < kDataLen; ++n) {
         EXPECT_EQ(kData[n].expected,
                   skin_size_contains(&kData[n].size,
                                      kData[n].x,
                                      kData[n].y)) << "#" << n;
     }
 }

 TEST(rect, skin_size_rotate) {
     static const struct {
         SkinSize expected;
         SkinSize size;
         SkinRotation rotation;
     } kData[] = {
         { { 0, 0 }, { 0, 0 }, SKIN_ROTATION_0 },
         { { 0, 0 }, { 0, 0 }, SKIN_ROTATION_90 },
         { { 0, 0 }, { 0, 0 }, SKIN_ROTATION_180 },
         { { 0, 0 }, { 0, 0 }, SKIN_ROTATION_270 },

         { { 100, 0 }, { 100, 0 }, SKIN_ROTATION_0 },
         { { 0, 100 }, { 100, 0 }, SKIN_ROTATION_90 },
         { { 100, 0 }, { 100, 0 }, SKIN_ROTATION_180 },
         { { 0, 100 }, { 100, 0 }, SKIN_ROTATION_270 },

         { { 0, 100 }, { 0, 100 }, SKIN_ROTATION_0 },
         { { 100, 0 }, { 0, 100 }, SKIN_ROTATION_90 },
         { { 0, 100 }, { 0, 100 }, SKIN_ROTATION_180 },
         { { 100, 0 }, { 0, 100 }, SKIN_ROTATION_270 },

         { { 100, 200 }, { 100, 200 }, SKIN_ROTATION_0 },
         { { 200, 100 }, { 100, 200 }, SKIN_ROTATION_90 },
         { { 100, 200 }, { 100, 200 }, SKIN_ROTATION_180 },
         { { 200, 100 }, { 100, 200 }, SKIN_ROTATION_270 },
     };
     const size_t kDataLen = ARRAYLEN(kData);
     for (size_t n = 0; n < kDataLen; ++n) {
         SkinSize result = kData[n].size;
         // Note: this checks that the function works when |src == dst|.
         skin_size_rotate(&result, &result, kData[n].rotation);
         EXPECT_EQ(kData[n].expected.w, result.w) << "#" << n;
         EXPECT_EQ(kData[n].expected.h, result.h) << "#" << n;
     }
 }

 TEST(rect, skin_rect_init) {
     SkinRect r;
     skin_rect_init(&r, 10, 20, 30, 40);
     EXPECT_EQ(10, r.pos.x);
     EXPECT_EQ(20, r.pos.y);
     EXPECT_EQ(30, r.size.w);
     EXPECT_EQ(40, r.size.h);

     skin_rect_init(&r, 10, 20, -30, 40);
     EXPECT_EQ(0, r.pos.x);
     EXPECT_EQ(0, r.pos.y);
     EXPECT_EQ(0, r.size.w);
     EXPECT_EQ(0, r.size.h);

     skin_rect_init(&r, 10, 20, 30, -40);
     EXPECT_EQ(0, r.pos.x);
     EXPECT_EQ(0, r.pos.y);
     EXPECT_EQ(0, r.size.w);
     EXPECT_EQ(0, r.size.h);

     skin_rect_init(&r, 10, 20, -30, -40);
     EXPECT_EQ(0, r.pos.x);
     EXPECT_EQ(0, r.pos.y);
     EXPECT_EQ(0, r.size.w);
     EXPECT_EQ(0, r.size.h);
 }

 TEST(rect, skin_rect_translate) {
     SkinRect r;
     skin_rect_init(&r, 10, 30, 50, 70);
     skin_rect_translate(&r, +5, -5);
     EXPECT_EQ(15, r.pos.x);
     EXPECT_EQ(25, r.pos.y);
     EXPECT_EQ(50, r.size.w);
     EXPECT_EQ(70, r.size.h);
 }

 TEST(rect, skin_rect_rotate) {
     static const struct {
         SkinRect expected;
         SkinRect rect;
         SkinRotation rotation;
     } kData[] = {
         { { { 10, 5 }, { 30, 70 } }, { { 10, 5 }, { 30, 70 } }, SKIN_ROTATION_0 },
         { { { -75, 10 }, { 70, 30 } }, { { 10, 5 }, { 30, 70 } }, SKIN_ROTATION_90 },
         { { { -40, -75 }, { 30, 70 } }, { { 10, 5 }, { 30, 70 } }, SKIN_ROTATION_180 },
         { { { 5, -40 }, { 70, 30 } }, { { 10, 5 }, { 30, 70 } }, SKIN_ROTATION_270 },
     };
     const size_t kDataLen = ARRAYLEN(kData);
     for (size_t n = 0; n < kDataLen; ++n) {
         SkinRect result = kData[n].rect;
         SkinRect expected = kData[n].expected;
         skin_rect_rotate(&result, &result, kData[n].rotation);
         EXPECT_EQ(expected.pos.x, result.pos.x) << "#" << n;
         EXPECT_EQ(expected.pos.y, result.pos.y) << "#" << n;
         EXPECT_EQ(expected.size.w, result.size.w) << "#" << n;
         EXPECT_EQ(expected.size.h, result.size.h) << "#" << n;
     }
 }

 TEST(rect, skin_rect_contains) {
     static const struct {
         bool expected;
         SkinRect rect;
         int x;
         int y;
     } kData[] = {
         { false, { { 0, 0 }, { 0, 0 } }, 0, 0 },
         { true, { { 0, 0 }, { 1, 1 } }, 0, 0 },

         { false, { { 10, 5 }, { 30, 70 } }, 9, 5 },
         { false, { { 10, 5 }, { 30, 70 } }, 10, 4 },
         { false, { { 10, 5 }, { 30, 70 } }, 40, 5 },
         { false, { { 10, 5 }, { 30, 70 } }, 10, 75 },
         { false, { { 10, 5 }, { 30, 70 } }, 40, 75 },

         { true, { { 10, 5 }, { 30, 70 } }, 10, 5 },
         { true, { { 10, 5 }, { 30, 70 } }, 39, 5 },
         { true, { { 10, 5 }, { 30, 70 } }, 10, 74 },
         { true, { { 10, 5 }, { 30, 70 } }, 39, 74 },
     };
     const size_t kDataLen = ARRAYLEN(kData);
     for (size_t n = 0; n < kDataLen; ++n) {
         EXPECT_EQ(kData[n].expected,
                   skin_rect_contains(&kData[n].rect,
                                      kData[n].x,
                                      kData[n].y)) << "#" << n;
     }
 }

 TEST(rect, skin_rect_contains_rect) {
     static const struct {
         SkinOverlap expected;
         SkinRect rect1;
         SkinRect rect2;
     } kData[] = {
         { SKIN_OUTSIDE, { { 0, 0 }, { 0, 0 } }, { { 0, 0 }, { 0, 0 } } },
         { SKIN_OUTSIDE, { { 0, 0 }, { 10, 20 } }, { { 10, 20 }, { 5, 5 } } },
         { SKIN_INSIDE, { { 0, 0 }, { 10, 20 } }, { { 5, 3 }, { 5, 5 } } },
         { SKIN_OVERLAP, { { 0, 0 }, { 10, 20 } }, { { 5, 3 }, { 15, 5 } } },
     };
     const size_t kDataLen = ARRAYLEN(kData);
     for (size_t n = 0; n < kDataLen; ++n) {
         EXPECT_EQ(kData[n].expected,
                   skin_rect_contains_rect(&kData[n].rect1,
                                           &kData[n].rect2)) << "#" << n;
     }
 }

 TEST(rect, skin_rect_intersect) {
     static const struct {
         bool expected;
         SkinRect result;
         SkinRect r1;
         SkinRect r2;
     } kData[] = {
         { false, {{ 0, 0},{ 0, 0}}, {{ 0, 0},{10,20}}, {{20, 0},{10,20}} },
         { true, {{20,20},{20,15}}, {{10,20},{30,30}}, {{20,10},{50,25}} },
         { true, {{20,40},{20,10}}, {{10,20},{30,30}}, {{20,40},{50,25}} },
     };
     const size_t kDataLen = ARRAYLEN(kData);
     for (size_t n = 0; n < kDataLen; ++n) {
         SkinRect result = { { 0, 0 }, { 0, 0 } };
         EXPECT_EQ(kData[n].expected,
                   skin_rect_intersect(&result, &kData[n].r1, &kData[n].r2))
                 << "#" << n;
         if (kData[n].expected) {
             EXPECT_EQ(kData[n].result.pos.x, result.pos.x) << "#" << n;
             EXPECT_EQ(kData[n].result.pos.y, result.pos.y) << "#" << n;
             EXPECT_EQ(kData[n].result.size.w, result.size.w) << "#" << n;
             EXPECT_EQ(kData[n].result.size.h, result.size.h) << "#" << n;
         }
     }
 }

 TEST(rect, skin_rect_equals) {
     static const struct {
         bool expected;
         SkinRect r1;
         SkinRect r2;
     } kData[] = {
         { false, {{ 0, 0},{10,20}}, {{20, 0},{10,20}} },

         { true, {{10,20},{30,40}}, {{10,20},{30,40}} },

         { false, {{10,20},{30,40}}, {{10,-20},{30,40}} },
         { false, {{10,20},{30,40}}, {{-10,20},{30,40}} },
         { false, {{10,20},{30,40}}, {{-10,-20},{30,40}} },
         { false, {{10,20},{30,40}}, {{-10,-20},{30,40}} },

         { false, {{10,20},{30,40}}, {{10,20},{35,40}} },
         { false, {{10,20},{30,40}}, {{10,20},{30,45}} },
         { false, {{10,20},{30,40}}, {{10,20},{35,45}} },
     };
     const size_t kDataLen = ARRAYLEN(kData);
     for (size_t n = 0; n < kDataLen; ++n) {
         const SkinRect* r1 = &kData[n].r1;
         const SkinRect* r2 = &kData[n].r2;
         EXPECT_EQ(kData[n].expected, skin_rect_equals(r1, r2))
                 << "#" << n
                 << " r1.x=" << r1->pos.x
                 << " r1.y=" << r1->pos.y
                 << " r1.w=" << r1->size.w
                 << " r1.h=" << r1->size.h
                 << " r2.x=" << r2->pos.x
                 << " r2.y=" << r2->pos.y
                 << " r2.w=" << r2->size.w
                 << " r2.h=" << r2->size.h;
     }
 }

 TEST(rect, skin_box_init) {
     SkinBox box = { 0, 0, 0, 0 };
     skin_box_init(&box, 10, 20, 30, 40);
     EXPECT_EQ(10, box.x1);
     EXPECT_EQ(20, box.y1);
     EXPECT_EQ(30, box.x2);
     EXPECT_EQ(40, box.y2);
 }

 TEST(rect, skin_box_from_rect) {
     SkinBox box = { 0, 0, 0, 0 };
     const SkinRect rect = { { 10, 20 }, { 30, 40 } };
     skin_box_from_rect(&box, &rect);
     EXPECT_EQ(10, box.x1);
     EXPECT_EQ(20, box.y1);
     EXPECT_EQ(40, box.x2);
     EXPECT_EQ(60, box.y2);
 }

 TEST(rect, skin_box_to_rect) {
     const SkinBox box = { 10, 20, 40, 60 };
     SkinRect rect;
     skin_box_to_rect(&box, &rect);
     EXPECT_EQ(10, rect.pos.x);
     EXPECT_EQ(20, rect.pos.y);
     EXPECT_EQ(30, rect.size.w);
     EXPECT_EQ(40, rect.size.h);
 }

 TEST(rect, skin_box_minmax_init) {
     SkinBox box = { 0, 0, 0, 0 };
     skin_box_minmax_init(&box);
 }

 TEST(rect, skin_box_minmax_to_rect) {
     const SkinRect r1 = {{10, 20},{30,40}};
     const SkinRect r2 = {{100,25},{50,50}};
     SkinBox box;
     skin_box_minmax_init(&box);

     skin_box_minmax_update(&box, &r1);
     skin_box_minmax_update(&box, &r2);

     SkinRect rect;
     skin_box_minmax_to_rect(&box, &rect);
     EXPECT_EQ(10,rect.pos.x);
     EXPECT_EQ(20,rect.pos.y);
     EXPECT_EQ(140,rect.size.w);
     EXPECT_EQ(55,rect.size.h);
 }

 }  // namespace android_skin
	/* Copyright (C) 2014 The Android Open Source Project
	**
	** This software is licensed under the terms of the GNU General Public
	** License version 2, as published by the Free Software Foundation, and
	** may be copied, distributed, and modified under those terms.
	**
	** This program is distributed in the hope that it will be useful,
	** but WITHOUT ANY WARRANTY; without even the implied warranty of
	** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	** GNU General Public License for more details.
	*/
	#include "android/skin/rect.h"

	#include <gtest/gtest.h>

	#define ARRAYLEN(x) (sizeof(x)/sizeof((x)[0]))

	namespace android_skin {

	TEST(rect, skin_pos_rotate) {
	static const struct {
	SkinPos expected;
	SkinPos pos;
	SkinRotation rotation;
	} kData[] = {
	{ { 0, 0 }, { 0, 0 }, SKIN_ROTATION_0 },
	{ { 0, 0 }, { 0, 0 }, SKIN_ROTATION_90 },
	{ { 0, 0 }, { 0, 0 }, SKIN_ROTATION_180 },
	{ { 0, 0 }, { 0, 0 }, SKIN_ROTATION_270 },

	{ { 100, 0 }, { 100, 0 }, SKIN_ROTATION_0 },
	{ { 0, 100 }, { 100, 0 }, SKIN_ROTATION_90 },
	{ { -100, 0 }, { 100, 0 }, SKIN_ROTATION_180 },
	{ { 0, -100 }, { 100, 0 }, SKIN_ROTATION_270 },

	{ { 0, 100 }, { 0, 100 }, SKIN_ROTATION_0 },
	{ { -100, 0 }, { 0, 100 }, SKIN_ROTATION_90 },
	{ { 0, -100 }, { 0, 100 }, SKIN_ROTATION_180 },
	{ { 100, 0 }, { 0, 100 }, SKIN_ROTATION_270 },

	{ { -100, 0 }, { -100, 0 }, SKIN_ROTATION_0 },
	{ { 0, -100 }, { -100, 0 }, SKIN_ROTATION_90 },
	{ { 100, 0 }, { -100, 0 }, SKIN_ROTATION_180 },
	{ { 0, 100 }, { -100, 0 }, SKIN_ROTATION_270 },

	{ { 0, -100 }, { 0, -100 }, SKIN_ROTATION_0 },
	{ { 100, 0 }, { 0, -100 }, SKIN_ROTATION_90 },
	{ { 0, 100 }, { 0, -100 }, SKIN_ROTATION_180 },
	{ { -100, 0 }, { 0, -100 }, SKIN_ROTATION_270 },

	{ { 100, 200 }, { 100, 200 }, SKIN_ROTATION_0 },
	{ { -200, 100 }, { 100, 200 }, SKIN_ROTATION_90 },
	{ { -100, -200 }, { 100, 200 }, SKIN_ROTATION_180 },
	{ { 200, -100 }, { 100, 200 }, SKIN_ROTATION_270 },
	};
	const size_t kDataLen = ARRAYLEN(kData);
	for (size_t n = 0; n < kDataLen; ++n) {
	SkinPos result = kData[n].pos;
	// Note: this checks that the function works when \|src == dst\|.
	skin_pos_rotate(&result, &result, kData[n].rotation);
	EXPECT_EQ(kData[n].expected.x, result.x) << "#" << n;
	EXPECT_EQ(kData[n].expected.y, result.y) << "#" << n;
	}
	}

	TEST(rect, skin_size_contains) {
	static const struct {
	bool expected;
	SkinSize size;
	int x;
	int y;
	} kData[] = {
	{ false, { 0, 0 }, 0, 0 },
	{ true, { 1, 1 }, 0, 0 },
	{ false, { 1, 1 }, 1, 1 },
	{ true, { 10, 20 }, 0, 0 },
	{ false, { 10, 20 }, 10, 0 },
	{ false, { 10, 20 }, 0, 20 },
	{ false, { 10, 20 }, 10, 20 },
	{ true, { 10, 20 }, 9, 19 },
	};
	const size_t kDataLen = ARRAYLEN(kData);
	for (size_t n = 0; n < kDataLen; ++n) {
	EXPECT_EQ(kData[n].expected,
	skin_size_contains(&kData[n].size,
	kData[n].x,
	kData[n].y)) << "#" << n;
	}
	}

	TEST(rect, skin_size_rotate) {
	static const struct {
	SkinSize expected;
	SkinSize size;
	SkinRotation rotation;
	} kData[] = {
	{ { 0, 0 }, { 0, 0 }, SKIN_ROTATION_0 },
	{ { 0, 0 }, { 0, 0 }, SKIN_ROTATION_90 },
	{ { 0, 0 }, { 0, 0 }, SKIN_ROTATION_180 },
	{ { 0, 0 }, { 0, 0 }, SKIN_ROTATION_270 },

	{ { 100, 0 }, { 100, 0 }, SKIN_ROTATION_0 },
	{ { 0, 100 }, { 100, 0 }, SKIN_ROTATION_90 },
	{ { 100, 0 }, { 100, 0 }, SKIN_ROTATION_180 },
	{ { 0, 100 }, { 100, 0 }, SKIN_ROTATION_270 },

	{ { 0, 100 }, { 0, 100 }, SKIN_ROTATION_0 },
	{ { 100, 0 }, { 0, 100 }, SKIN_ROTATION_90 },
	{ { 0, 100 }, { 0, 100 }, SKIN_ROTATION_180 },
	{ { 100, 0 }, { 0, 100 }, SKIN_ROTATION_270 },

	{ { 100, 200 }, { 100, 200 }, SKIN_ROTATION_0 },
	{ { 200, 100 }, { 100, 200 }, SKIN_ROTATION_90 },
	{ { 100, 200 }, { 100, 200 }, SKIN_ROTATION_180 },
	{ { 200, 100 }, { 100, 200 }, SKIN_ROTATION_270 },
	};
	const size_t kDataLen = ARRAYLEN(kData);
	for (size_t n = 0; n < kDataLen; ++n) {
	SkinSize result = kData[n].size;
	// Note: this checks that the function works when \|src == dst\|.
	skin_size_rotate(&result, &result, kData[n].rotation);
	EXPECT_EQ(kData[n].expected.w, result.w) << "#" << n;
	EXPECT_EQ(kData[n].expected.h, result.h) << "#" << n;
	}
	}

	TEST(rect, skin_rect_init) {
	SkinRect r;
	skin_rect_init(&r, 10, 20, 30, 40);
	EXPECT_EQ(10, r.pos.x);
	EXPECT_EQ(20, r.pos.y);
	EXPECT_EQ(30, r.size.w);
	EXPECT_EQ(40, r.size.h);

	skin_rect_init(&r, 10, 20, -30, 40);
	EXPECT_EQ(0, r.pos.x);
	EXPECT_EQ(0, r.pos.y);
	EXPECT_EQ(0, r.size.w);
	EXPECT_EQ(0, r.size.h);

	skin_rect_init(&r, 10, 20, 30, -40);
	EXPECT_EQ(0, r.pos.x);
	EXPECT_EQ(0, r.pos.y);
	EXPECT_EQ(0, r.size.w);
	EXPECT_EQ(0, r.size.h);

	skin_rect_init(&r, 10, 20, -30, -40);
	EXPECT_EQ(0, r.pos.x);
	EXPECT_EQ(0, r.pos.y);
	EXPECT_EQ(0, r.size.w);
	EXPECT_EQ(0, r.size.h);
	}

	TEST(rect, skin_rect_translate) {
	SkinRect r;
	skin_rect_init(&r, 10, 30, 50, 70);
	skin_rect_translate(&r, +5, -5);
	EXPECT_EQ(15, r.pos.x);
	EXPECT_EQ(25, r.pos.y);
	EXPECT_EQ(50, r.size.w);
	EXPECT_EQ(70, r.size.h);
	}

	TEST(rect, skin_rect_rotate) {
	static const struct {
	SkinRect expected;
	SkinRect rect;
	SkinRotation rotation;
	} kData[] = {
	{ { { 10, 5 }, { 30, 70 } }, { { 10, 5 }, { 30, 70 } }, SKIN_ROTATION_0 },
	{ { { -75, 10 }, { 70, 30 } }, { { 10, 5 }, { 30, 70 } }, SKIN_ROTATION_90 },
	{ { { -40, -75 }, { 30, 70 } }, { { 10, 5 }, { 30, 70 } }, SKIN_ROTATION_180 },
	{ { { 5, -40 }, { 70, 30 } }, { { 10, 5 }, { 30, 70 } }, SKIN_ROTATION_270 },
	};
	const size_t kDataLen = ARRAYLEN(kData);
	for (size_t n = 0; n < kDataLen; ++n) {
	SkinRect result = kData[n].rect;
	SkinRect expected = kData[n].expected;
	skin_rect_rotate(&result, &result, kData[n].rotation);
	EXPECT_EQ(expected.pos.x, result.pos.x) << "#" << n;
	EXPECT_EQ(expected.pos.y, result.pos.y) << "#" << n;
	EXPECT_EQ(expected.size.w, result.size.w) << "#" << n;
	EXPECT_EQ(expected.size.h, result.size.h) << "#" << n;
	}
	}

	TEST(rect, skin_rect_contains) {
	static const struct {
	bool expected;
	SkinRect rect;
	int x;
	int y;
	} kData[] = {
	{ false, { { 0, 0 }, { 0, 0 } }, 0, 0 },
	{ true, { { 0, 0 }, { 1, 1 } }, 0, 0 },

	{ false, { { 10, 5 }, { 30, 70 } }, 9, 5 },
	{ false, { { 10, 5 }, { 30, 70 } }, 10, 4 },
	{ false, { { 10, 5 }, { 30, 70 } }, 40, 5 },
	{ false, { { 10, 5 }, { 30, 70 } }, 10, 75 },
	{ false, { { 10, 5 }, { 30, 70 } }, 40, 75 },

	{ true, { { 10, 5 }, { 30, 70 } }, 10, 5 },
	{ true, { { 10, 5 }, { 30, 70 } }, 39, 5 },
	{ true, { { 10, 5 }, { 30, 70 } }, 10, 74 },
	{ true, { { 10, 5 }, { 30, 70 } }, 39, 74 },
	};
	const size_t kDataLen = ARRAYLEN(kData);
	for (size_t n = 0; n < kDataLen; ++n) {
	EXPECT_EQ(kData[n].expected,
	skin_rect_contains(&kData[n].rect,
	kData[n].x,
	kData[n].y)) << "#" << n;
	}
	}

	TEST(rect, skin_rect_contains_rect) {
	static const struct {
	SkinOverlap expected;
	SkinRect rect1;
	SkinRect rect2;
	} kData[] = {
	{ SKIN_OUTSIDE, { { 0, 0 }, { 0, 0 } }, { { 0, 0 }, { 0, 0 } } },
	{ SKIN_OUTSIDE, { { 0, 0 }, { 10, 20 } }, { { 10, 20 }, { 5, 5 } } },
	{ SKIN_INSIDE, { { 0, 0 }, { 10, 20 } }, { { 5, 3 }, { 5, 5 } } },
	{ SKIN_OVERLAP, { { 0, 0 }, { 10, 20 } }, { { 5, 3 }, { 15, 5 } } },
	};
	const size_t kDataLen = ARRAYLEN(kData);
	for (size_t n = 0; n < kDataLen; ++n) {
	EXPECT_EQ(kData[n].expected,
	skin_rect_contains_rect(&kData[n].rect1,
	&kData[n].rect2)) << "#" << n;
	}
	}

	TEST(rect, skin_rect_intersect) {
	static const struct {
	bool expected;
	SkinRect result;
	SkinRect r1;
	SkinRect r2;
	} kData[] = {
	{ false, {{ 0, 0},{ 0, 0}}, {{ 0, 0},{10,20}}, {{20, 0},{10,20}} },
	{ true, {{20,20},{20,15}}, {{10,20},{30,30}}, {{20,10},{50,25}} },
	{ true, {{20,40},{20,10}}, {{10,20},{30,30}}, {{20,40},{50,25}} },
	};
	const size_t kDataLen = ARRAYLEN(kData);
	for (size_t n = 0; n < kDataLen; ++n) {
	SkinRect result = { { 0, 0 }, { 0, 0 } };
	EXPECT_EQ(kData[n].expected,
	skin_rect_intersect(&result, &kData[n].r1, &kData[n].r2))
	<< "#" << n;
	if (kData[n].expected) {
	EXPECT_EQ(kData[n].result.pos.x, result.pos.x) << "#" << n;
	EXPECT_EQ(kData[n].result.pos.y, result.pos.y) << "#" << n;
	EXPECT_EQ(kData[n].result.size.w, result.size.w) << "#" << n;
	EXPECT_EQ(kData[n].result.size.h, result.size.h) << "#" << n;
	}
	}
	}

	TEST(rect, skin_rect_equals) {
	static const struct {
	bool expected;
	SkinRect r1;
	SkinRect r2;
	} kData[] = {
	{ false, {{ 0, 0},{10,20}}, {{20, 0},{10,20}} },

	{ true, {{10,20},{30,40}}, {{10,20},{30,40}} },

	{ false, {{10,20},{30,40}}, {{10,-20},{30,40}} },
	{ false, {{10,20},{30,40}}, {{-10,20},{30,40}} },
	{ false, {{10,20},{30,40}}, {{-10,-20},{30,40}} },
	{ false, {{10,20},{30,40}}, {{-10,-20},{30,40}} },

	{ false, {{10,20},{30,40}}, {{10,20},{35,40}} },
	{ false, {{10,20},{30,40}}, {{10,20},{30,45}} },
	{ false, {{10,20},{30,40}}, {{10,20},{35,45}} },
	};
	const size_t kDataLen = ARRAYLEN(kData);
	for (size_t n = 0; n < kDataLen; ++n) {
	const SkinRect* r1 = &kData[n].r1;
	const SkinRect* r2 = &kData[n].r2;
	EXPECT_EQ(kData[n].expected, skin_rect_equals(r1, r2))
	<< "#" << n
	<< " r1.x=" << r1->pos.x
	<< " r1.y=" << r1->pos.y
	<< " r1.w=" << r1->size.w
	<< " r1.h=" << r1->size.h
	<< " r2.x=" << r2->pos.x
	<< " r2.y=" << r2->pos.y
	<< " r2.w=" << r2->size.w
	<< " r2.h=" << r2->size.h;
	}
	}

	TEST(rect, skin_box_init) {
	SkinBox box = { 0, 0, 0, 0 };
	skin_box_init(&box, 10, 20, 30, 40);
	EXPECT_EQ(10, box.x1);
	EXPECT_EQ(20, box.y1);
	EXPECT_EQ(30, box.x2);
	EXPECT_EQ(40, box.y2);
	}

	TEST(rect, skin_box_from_rect) {
	SkinBox box = { 0, 0, 0, 0 };
	const SkinRect rect = { { 10, 20 }, { 30, 40 } };
	skin_box_from_rect(&box, &rect);
	EXPECT_EQ(10, box.x1);
	EXPECT_EQ(20, box.y1);
	EXPECT_EQ(40, box.x2);
	EXPECT_EQ(60, box.y2);
	}

	TEST(rect, skin_box_to_rect) {
	const SkinBox box = { 10, 20, 40, 60 };
	SkinRect rect;
	skin_box_to_rect(&box, &rect);
	EXPECT_EQ(10, rect.pos.x);
	EXPECT_EQ(20, rect.pos.y);
	EXPECT_EQ(30, rect.size.w);
	EXPECT_EQ(40, rect.size.h);
	}

	TEST(rect, skin_box_minmax_init) {
	SkinBox box = { 0, 0, 0, 0 };
	skin_box_minmax_init(&box);
	}

	TEST(rect, skin_box_minmax_to_rect) {
	const SkinRect r1 = {{10, 20},{30,40}};
	const SkinRect r2 = {{100,25},{50,50}};
	SkinBox box;
	skin_box_minmax_init(&box);

	skin_box_minmax_update(&box, &r1);
	skin_box_minmax_update(&box, &r2);

	SkinRect rect;
	skin_box_minmax_to_rect(&box, &rect);
	EXPECT_EQ(10,rect.pos.x);
	EXPECT_EQ(20,rect.pos.y);
	EXPECT_EQ(140,rect.size.w);
	EXPECT_EQ(55,rect.size.h);
	}

	} // namespace android_skin