/* 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