зеркало из https://github.com/mozilla/moz-skia.git
466 строки
17 KiB
C++
466 строки
17 KiB
C++
/*
|
|
* Copyright 2012 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "Test.h"
|
|
#include "SkRRect.h"
|
|
|
|
static const SkScalar kWidth = 100.0f;
|
|
static const SkScalar kHeight = 100.0f;
|
|
|
|
static void test_inset(skiatest::Reporter* reporter) {
|
|
SkRRect rr, rr2;
|
|
SkRect r = { 0, 0, 100, 100 };
|
|
|
|
rr.setRect(r);
|
|
rr.inset(-20, -20, &rr2);
|
|
REPORTER_ASSERT(reporter, rr2.isRect());
|
|
|
|
rr.inset(20, 20, &rr2);
|
|
REPORTER_ASSERT(reporter, rr2.isRect());
|
|
|
|
rr.inset(r.width()/2, r.height()/2, &rr2);
|
|
REPORTER_ASSERT(reporter, rr2.isEmpty());
|
|
|
|
rr.setRectXY(r, 20, 20);
|
|
rr.inset(19, 19, &rr2);
|
|
REPORTER_ASSERT(reporter, rr2.isSimple());
|
|
rr.inset(20, 20, &rr2);
|
|
REPORTER_ASSERT(reporter, rr2.isRect());
|
|
}
|
|
|
|
// Test out the basic API entry points
|
|
static void test_round_rect_basic(skiatest::Reporter* reporter) {
|
|
// Test out initialization methods
|
|
SkPoint zeroPt = { 0, 0 };
|
|
SkRRect empty;
|
|
|
|
empty.setEmpty();
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kEmpty_Type == empty.type());
|
|
REPORTER_ASSERT(reporter, empty.rect().isEmpty());
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
REPORTER_ASSERT(reporter, zeroPt == empty.radii((SkRRect::Corner) i));
|
|
}
|
|
|
|
//----
|
|
SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight);
|
|
|
|
SkRRect rr1;
|
|
rr1.setRect(rect);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kRect_Type == rr1.type());
|
|
REPORTER_ASSERT(reporter, rr1.rect() == rect);
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
REPORTER_ASSERT(reporter, zeroPt == rr1.radii((SkRRect::Corner) i));
|
|
}
|
|
|
|
//----
|
|
SkPoint halfPoint = { SkScalarHalf(kWidth), SkScalarHalf(kHeight) };
|
|
SkRRect rr2;
|
|
rr2.setOval(rect);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kOval_Type == rr2.type());
|
|
REPORTER_ASSERT(reporter, rr2.rect() == rect);
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
REPORTER_ASSERT(reporter,
|
|
rr2.radii((SkRRect::Corner) i).equalsWithinTolerance(halfPoint));
|
|
}
|
|
|
|
//----
|
|
SkPoint p = { 5, 5 };
|
|
SkRRect rr3;
|
|
rr3.setRectXY(rect, p.fX, p.fY);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kSimple_Type == rr3.type());
|
|
REPORTER_ASSERT(reporter, rr3.rect() == rect);
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
REPORTER_ASSERT(reporter, p == rr3.radii((SkRRect::Corner) i));
|
|
}
|
|
|
|
//----
|
|
SkPoint radii[4] = { { 5, 5 }, { 5, 5 }, { 5, 5 }, { 5, 5 } };
|
|
|
|
SkRRect rr4;
|
|
rr4.setRectRadii(rect, radii);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kSimple_Type == rr4.type());
|
|
REPORTER_ASSERT(reporter, rr4.rect() == rect);
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
REPORTER_ASSERT(reporter, radii[i] == rr4.radii((SkRRect::Corner) i));
|
|
}
|
|
|
|
//----
|
|
SkPoint radii2[4] = { { 0, 0 }, { 0, 0 }, { 50, 50 }, { 20, 50 } };
|
|
|
|
SkRRect rr5;
|
|
rr5.setRectRadii(rect, radii2);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kComplex_Type == rr5.type());
|
|
REPORTER_ASSERT(reporter, rr5.rect() == rect);
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
REPORTER_ASSERT(reporter, radii2[i] == rr5.radii((SkRRect::Corner) i));
|
|
}
|
|
|
|
// Test out == & !=
|
|
REPORTER_ASSERT(reporter, empty != rr3);
|
|
REPORTER_ASSERT(reporter, rr3 == rr4);
|
|
REPORTER_ASSERT(reporter, rr4 != rr5);
|
|
}
|
|
|
|
// Test out the cases when the RR degenerates to a rect
|
|
static void test_round_rect_rects(skiatest::Reporter* reporter) {
|
|
SkRect r;
|
|
static const SkPoint pts[] = {
|
|
// Upper Left
|
|
{ -SK_Scalar1, -SK_Scalar1 }, // out
|
|
{ SK_Scalar1, SK_Scalar1 }, // in
|
|
// Upper Right
|
|
{ SkIntToScalar(101), -SK_Scalar1}, // out
|
|
{ SkIntToScalar(99), SK_Scalar1 }, // in
|
|
// Lower Right
|
|
{ SkIntToScalar(101), SkIntToScalar(101) }, // out
|
|
{ SkIntToScalar(99), SkIntToScalar(99) }, // in
|
|
// Lower Left
|
|
{ -SK_Scalar1, SkIntToScalar(101) }, // out
|
|
{ SK_Scalar1, SkIntToScalar(99) }, // in
|
|
// Middle
|
|
{ SkIntToScalar(50), SkIntToScalar(50) } // in
|
|
};
|
|
static const bool isIn[] = { false, true, false, true, false, true, false, true, true };
|
|
|
|
SkASSERT(SK_ARRAY_COUNT(pts) == SK_ARRAY_COUNT(isIn));
|
|
|
|
//----
|
|
SkRRect empty;
|
|
|
|
empty.setEmpty();
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kEmpty_Type == empty.type());
|
|
r = empty.rect();
|
|
REPORTER_ASSERT(reporter, 0 == r.fLeft && 0 == r.fTop && 0 == r.fRight && 0 == r.fBottom);
|
|
|
|
//----
|
|
SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight);
|
|
SkRRect rr1;
|
|
rr1.setRectXY(rect, 0, 0);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kRect_Type == rr1.type());
|
|
r = rr1.rect();
|
|
REPORTER_ASSERT(reporter, rect == r);
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(pts); ++i) {
|
|
REPORTER_ASSERT(reporter, isIn[i] == rr1.contains(pts[i].fX, pts[i].fY));
|
|
}
|
|
|
|
//----
|
|
SkPoint radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } };
|
|
|
|
SkRRect rr2;
|
|
rr2.setRectRadii(rect, radii);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kRect_Type == rr2.type());
|
|
r = rr2.rect();
|
|
REPORTER_ASSERT(reporter, rect == r);
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(pts); ++i) {
|
|
REPORTER_ASSERT(reporter, isIn[i] == rr2.contains(pts[i].fX, pts[i].fY));
|
|
}
|
|
|
|
//----
|
|
SkPoint radii2[4] = { { 0, 0 }, { 20, 20 }, { 50, 50 }, { 20, 50 } };
|
|
|
|
SkRRect rr3;
|
|
rr3.setRectRadii(rect, radii2);
|
|
REPORTER_ASSERT(reporter, SkRRect::kComplex_Type == rr3.type());
|
|
}
|
|
|
|
// Test out the cases when the RR degenerates to an oval
|
|
static void test_round_rect_ovals(skiatest::Reporter* reporter) {
|
|
static const SkScalar kEps = 0.1f;
|
|
static const SkScalar kWidthTol = SkScalarHalf(kWidth) * (SK_Scalar1 - SK_ScalarRoot2Over2);
|
|
static const SkScalar kHeightTol = SkScalarHalf(kHeight) * (SK_Scalar1 - SK_ScalarRoot2Over2);
|
|
static const SkPoint pts[] = {
|
|
// Upper Left
|
|
{ kWidthTol - kEps, kHeightTol - kEps }, // out
|
|
{ kWidthTol + kEps, kHeightTol + kEps }, // in
|
|
// Upper Right
|
|
{ kWidth + kEps - kWidthTol, kHeightTol - kEps }, // out
|
|
{ kWidth - kEps - kWidthTol, kHeightTol + kEps }, // in
|
|
// Lower Right
|
|
{ kWidth + kEps - kWidthTol, kHeight + kEps - kHeightTol }, // out
|
|
{ kWidth - kEps - kWidthTol, kHeight - kEps - kHeightTol }, // in
|
|
// Lower Left
|
|
{ kWidthTol - kEps, kHeight + kEps - kHeightTol }, //out
|
|
{ kWidthTol + kEps, kHeight - kEps - kHeightTol }, // in
|
|
// Middle
|
|
{ SkIntToScalar(50), SkIntToScalar(50) } // in
|
|
};
|
|
static const bool isIn[] = { false, true, false, true, false, true, false, true, true };
|
|
|
|
SkASSERT(SK_ARRAY_COUNT(pts) == SK_ARRAY_COUNT(isIn));
|
|
|
|
//----
|
|
SkRect oval;
|
|
SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight);
|
|
SkRRect rr1;
|
|
rr1.setRectXY(rect, SkScalarHalf(kWidth), SkScalarHalf(kHeight));
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kOval_Type == rr1.type());
|
|
oval = rr1.rect();
|
|
REPORTER_ASSERT(reporter, oval == rect);
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(pts); ++i) {
|
|
REPORTER_ASSERT(reporter, isIn[i] == rr1.contains(pts[i].fX, pts[i].fY));
|
|
}
|
|
}
|
|
|
|
// Test out the non-degenerate RR cases
|
|
static void test_round_rect_general(skiatest::Reporter* reporter) {
|
|
static const SkScalar kEps = 0.1f;
|
|
static const SkScalar kDist20 = 20 * (SK_Scalar1 - SK_ScalarRoot2Over2);
|
|
static const SkPoint pts[] = {
|
|
// Upper Left
|
|
{ kDist20 - kEps, kDist20 - kEps }, // out
|
|
{ kDist20 + kEps, kDist20 + kEps }, // in
|
|
// Upper Right
|
|
{ kWidth + kEps - kDist20, kDist20 - kEps }, // out
|
|
{ kWidth - kEps - kDist20, kDist20 + kEps }, // in
|
|
// Lower Right
|
|
{ kWidth + kEps - kDist20, kHeight + kEps - kDist20 }, // out
|
|
{ kWidth - kEps - kDist20, kHeight - kEps - kDist20 }, // in
|
|
// Lower Left
|
|
{ kDist20 - kEps, kHeight + kEps - kDist20 }, //out
|
|
{ kDist20 + kEps, kHeight - kEps - kDist20 }, // in
|
|
// Middle
|
|
{ SkIntToScalar(50), SkIntToScalar(50) } // in
|
|
};
|
|
static const bool isIn[] = { false, true, false, true, false, true, false, true, true };
|
|
|
|
SkASSERT(SK_ARRAY_COUNT(pts) == SK_ARRAY_COUNT(isIn));
|
|
|
|
//----
|
|
SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight);
|
|
SkRRect rr1;
|
|
rr1.setRectXY(rect, 20, 20);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kSimple_Type == rr1.type());
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(pts); ++i) {
|
|
REPORTER_ASSERT(reporter, isIn[i] == rr1.contains(pts[i].fX, pts[i].fY));
|
|
}
|
|
|
|
//----
|
|
static const SkScalar kDist50 = 50*(SK_Scalar1 - SK_ScalarRoot2Over2);
|
|
static const SkPoint pts2[] = {
|
|
// Upper Left
|
|
{ -SK_Scalar1, -SK_Scalar1 }, // out
|
|
{ SK_Scalar1, SK_Scalar1 }, // in
|
|
// Upper Right
|
|
{ kWidth + kEps - kDist20, kDist20 - kEps }, // out
|
|
{ kWidth - kEps - kDist20, kDist20 + kEps }, // in
|
|
// Lower Right
|
|
{ kWidth + kEps - kDist50, kHeight + kEps - kDist50 }, // out
|
|
{ kWidth - kEps - kDist50, kHeight - kEps - kDist50 }, // in
|
|
// Lower Left
|
|
{ kDist20 - kEps, kHeight + kEps - kDist50 }, // out
|
|
{ kDist20 + kEps, kHeight - kEps - kDist50 }, // in
|
|
// Middle
|
|
{ SkIntToScalar(50), SkIntToScalar(50) } // in
|
|
};
|
|
|
|
SkASSERT(SK_ARRAY_COUNT(pts2) == SK_ARRAY_COUNT(isIn));
|
|
|
|
SkPoint radii[4] = { { 0, 0 }, { 20, 20 }, { 50, 50 }, { 20, 50 } };
|
|
|
|
SkRRect rr2;
|
|
rr2.setRectRadii(rect, radii);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kComplex_Type == rr2.type());
|
|
for (size_t i = 0; i < SK_ARRAY_COUNT(pts); ++i) {
|
|
REPORTER_ASSERT(reporter, isIn[i] == rr2.contains(pts2[i].fX, pts2[i].fY));
|
|
}
|
|
}
|
|
|
|
// Test out questionable-parameter handling
|
|
static void test_round_rect_iffy_parameters(skiatest::Reporter* reporter) {
|
|
|
|
// When the radii exceed the base rect they are proportionally scaled down
|
|
// to fit
|
|
SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight);
|
|
SkPoint radii[4] = { { 50, 100 }, { 100, 50 }, { 50, 100 }, { 100, 50 } };
|
|
|
|
SkRRect rr1;
|
|
rr1.setRectRadii(rect, radii);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kComplex_Type == rr1.type());
|
|
|
|
const SkPoint& p = rr1.radii(SkRRect::kUpperLeft_Corner);
|
|
|
|
REPORTER_ASSERT(reporter, SkScalarNearlyEqual(p.fX, 33.33333f));
|
|
REPORTER_ASSERT(reporter, SkScalarNearlyEqual(p.fY, 66.66666f));
|
|
|
|
// Negative radii should be capped at zero
|
|
SkRRect rr2;
|
|
rr2.setRectXY(rect, -10, -20);
|
|
|
|
REPORTER_ASSERT(reporter, SkRRect::kRect_Type == rr2.type());
|
|
|
|
const SkPoint& p2 = rr2.radii(SkRRect::kUpperLeft_Corner);
|
|
|
|
REPORTER_ASSERT(reporter, 0.0f == p2.fX);
|
|
REPORTER_ASSERT(reporter, 0.0f == p2.fY);
|
|
}
|
|
|
|
// Move a small box from the start position by (stepX, stepY) 'numSteps' times
|
|
// testing for containment in 'rr' at each step.
|
|
static void test_direction(skiatest::Reporter* reporter, const SkRRect &rr,
|
|
SkScalar initX, int stepX, SkScalar initY, int stepY,
|
|
int numSteps, const bool* contains) {
|
|
SkScalar x = initX, y = initY;
|
|
for (int i = 0; i < numSteps; ++i) {
|
|
SkRect test = SkRect::MakeXYWH(x, y,
|
|
stepX ? SkIntToScalar(stepX) : SK_Scalar1,
|
|
stepY ? SkIntToScalar(stepY) : SK_Scalar1);
|
|
test.sort();
|
|
|
|
REPORTER_ASSERT(reporter, contains[i] == rr.contains(test));
|
|
|
|
x += stepX;
|
|
y += stepY;
|
|
}
|
|
}
|
|
|
|
// Exercise the RR's contains rect method
|
|
static void test_round_rect_contains_rect(skiatest::Reporter* reporter) {
|
|
|
|
static const int kNumRRects = 4;
|
|
static const SkVector gRadii[kNumRRects][4] = {
|
|
{ { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }, // rect
|
|
{ { 20, 20 }, { 20, 20 }, { 20, 20 }, { 20, 20 } }, // circle
|
|
{ { 10, 10 }, { 10, 10 }, { 10, 10 }, { 10, 10 } }, // simple
|
|
{ { 0, 0 }, { 20, 20 }, { 10, 10 }, { 30, 30 } } // complex
|
|
};
|
|
|
|
SkRRect rrects[kNumRRects];
|
|
for (int i = 0; i < kNumRRects; ++i) {
|
|
rrects[i].setRectRadii(SkRect::MakeWH(40, 40), gRadii[i]);
|
|
}
|
|
|
|
// First test easy outs - boxes that are obviously out on
|
|
// each corner and edge
|
|
static const SkRect easyOuts[] = {
|
|
{ -5, -5, 5, 5 }, // NW
|
|
{ 15, -5, 20, 5 }, // N
|
|
{ 35, -5, 45, 5 }, // NE
|
|
{ 35, 15, 45, 20 }, // E
|
|
{ 35, 45, 35, 45 }, // SE
|
|
{ 15, 35, 20, 45 }, // S
|
|
{ -5, 35, 5, 45 }, // SW
|
|
{ -5, 15, 5, 20 } // W
|
|
};
|
|
|
|
for (int i = 0; i < kNumRRects; ++i) {
|
|
for (size_t j = 0; j < SK_ARRAY_COUNT(easyOuts); ++j) {
|
|
REPORTER_ASSERT(reporter, !rrects[i].contains(easyOuts[j]));
|
|
}
|
|
}
|
|
|
|
// Now test non-trivial containment. For each compass
|
|
// point walk a 1x1 rect in from the edge of the bounding
|
|
// rect
|
|
static const int kNumSteps = 15;
|
|
bool answers[kNumRRects][8][kNumSteps] = {
|
|
// all the test rects are inside the degenerate rrect
|
|
{
|
|
// rect
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
},
|
|
// for the circle we expect 6 blocks to be out on the
|
|
// corners (then the rest in) and only the first block
|
|
// out on the vertical and horizontal axes (then
|
|
// the rest in)
|
|
{
|
|
// circle
|
|
{ 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
},
|
|
// for the simple round rect we expect 3 out on
|
|
// the corners (then the rest in) and no blocks out
|
|
// on the vertical and horizontal axes
|
|
{
|
|
// simple RR
|
|
{ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
},
|
|
// for the complex case the answer is different for each direction
|
|
{
|
|
// complex RR
|
|
// all in for NW (rect) corner (same as rect case)
|
|
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
// only first block out for N (same as circle case)
|
|
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
// first 6 blocks out for NE (same as circle case)
|
|
{ 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
// only first block out for E (same as circle case)
|
|
{ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
// first 3 blocks out for SE (same as simple case)
|
|
{ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
// first two blocks out for S
|
|
{ 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
// first 9 blocks out for SW
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 },
|
|
// first two blocks out for W (same as S)
|
|
{ 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
|
|
}
|
|
};
|
|
|
|
for (int i = 0; i < kNumRRects; ++i) {
|
|
test_direction(reporter, rrects[i], 0, 1, 0, 1, kNumSteps, answers[i][0]); // NW
|
|
test_direction(reporter, rrects[i], 19.5f, 0, 0, 1, kNumSteps, answers[i][1]); // N
|
|
test_direction(reporter, rrects[i], 40, -1, 0, 1, kNumSteps, answers[i][2]); // NE
|
|
test_direction(reporter, rrects[i], 40, -1, 19.5f, 0, kNumSteps, answers[i][3]); // E
|
|
test_direction(reporter, rrects[i], 40, -1, 40, -1, kNumSteps, answers[i][4]); // SE
|
|
test_direction(reporter, rrects[i], 19.5f, 0, 40, -1, kNumSteps, answers[i][5]); // S
|
|
test_direction(reporter, rrects[i], 0, 1, 40, -1, kNumSteps, answers[i][6]); // SW
|
|
test_direction(reporter, rrects[i], 0, 1, 19.5f, 0, kNumSteps, answers[i][7]); // W
|
|
}
|
|
}
|
|
|
|
static void TestRoundRect(skiatest::Reporter* reporter) {
|
|
test_round_rect_basic(reporter);
|
|
test_round_rect_rects(reporter);
|
|
test_round_rect_ovals(reporter);
|
|
test_round_rect_general(reporter);
|
|
test_round_rect_iffy_parameters(reporter);
|
|
test_inset(reporter);
|
|
test_round_rect_contains_rect(reporter);
|
|
}
|
|
|
|
#include "TestClassDef.h"
|
|
DEFINE_TESTCLASS("RoundRect", TestRoundRectClass, TestRoundRect)
|