mirror of
https://github.com/dart-lang/sdk
synced 2024-10-14 09:12:08 +00:00
Fix behavior for -infinity width/height of rectangles.
Fixes #30186 BUG= dartbug.com/30186 Change-Id: I2994d180a4dc4d4e4bba7edec67bc2bcc2e8fc0b Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/201568 Auto-Submit: Lasse R.H. Nielsen <lrn@google.com> Commit-Queue: Lasse R.H. Nielsen <lrn@google.com> Reviewed-by: Erik Ernst <eernst@google.com>
This commit is contained in:
Lasse R.H. Nielsen
commit-bot@chromium.org
parent
d3ae296953
commit
19252d5786
|
|
@ -137,9 +137,12 @@ class Rectangle<T extends num> extends _RectangleBase<T> {
|
|||
/// single point `(left, top)`.
|
||||
const Rectangle(this.left, this.top, T width, T height)
|
||||
: width = (width < 0)
|
||||
? (-width * 0) as dynamic
|
||||
: width, // Inline _clampToZero<num>.
|
||||
height = (height < 0) ? (-height * 0) as dynamic : height;
|
||||
? (width == double.negativeInfinity ? 0.0 : (-width * 0)) as dynamic
|
||||
: (width + 0 as dynamic), // Inline _clampToZero<num>.
|
||||
height = (height < 0)
|
||||
? (height == double.negativeInfinity ? 0.0 : (-height * 0))
|
||||
as dynamic
|
||||
: (height + 0 as dynamic);
|
||||
|
||||
/// Create a rectangle spanned by the points [a] and [b];
|
||||
///
|
||||
|
|
@ -189,8 +192,10 @@ class MutableRectangle<T extends num> extends _RectangleBase<T>
|
|||
/// If `width` and `height` are zero, the "rectangle" comprises only the
|
||||
/// single point `(left, top)`.
|
||||
MutableRectangle(this.left, this.top, T width, T height)
|
||||
: this._width = (width < 0) ? _clampToZero<T>(width) : width,
|
||||
this._height = (height < 0) ? _clampToZero<T>(height) : height;
|
||||
: this._width =
|
||||
(width < 0) ? _clampToZero<T>(width) : (width + 0 as dynamic),
|
||||
this._height =
|
||||
(height < 0) ? _clampToZero<T>(height) : (height + 0 as dynamic);
|
||||
|
||||
/// Create a mutable rectangle spanned by the points [a] and [b];
|
||||
///
|
||||
|
|
@ -244,5 +249,6 @@ class MutableRectangle<T extends num> extends _RectangleBase<T>
|
|||
/// Returns `0` if value is int, `0.0` if value is double.
|
||||
T _clampToZero<T extends num>(T value) {
|
||||
assert(value < 0);
|
||||
return (-value * 0) as T;
|
||||
if (value == double.negativeInfinity) return 0.0 as dynamic;
|
||||
return (-value * 0) as dynamic;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,25 +22,24 @@ main() {
|
|||
testNaNHeight();
|
||||
}
|
||||
|
||||
Rectangle? createRectangle(List<num>? a) {
|
||||
return a != null ? new Rectangle(a[0], a[1], a[2] - a[0], a[3] - a[1]) : null;
|
||||
}
|
||||
Rectangle? createRectangle(List<num>? a) =>
|
||||
a != null ? Rectangle(a[0], a[1], a[2] - a[0], a[3] - a[1]) : null;
|
||||
|
||||
testConstruction() {
|
||||
var r0 = new Rectangle(10, 20, 30, 40);
|
||||
var r0 = Rectangle(10, 20, 30, 40);
|
||||
Expect.equals('Rectangle (10, 20) 30 x 40', r0.toString());
|
||||
Expect.equals(40, r0.right);
|
||||
Expect.equals(60, r0.bottom);
|
||||
|
||||
var r1 = new Rectangle.fromPoints(r0.topLeft, r0.bottomRight);
|
||||
var r1 = Rectangle.fromPoints(r0.topLeft, r0.bottomRight);
|
||||
Expect.equals(r0, r1);
|
||||
|
||||
var r2 = new Rectangle.fromPoints(r0.bottomRight, r0.topLeft);
|
||||
var r2 = Rectangle.fromPoints(r0.bottomRight, r0.topLeft);
|
||||
Expect.equals(r0, r2);
|
||||
}
|
||||
|
||||
testIntersection() {
|
||||
var tests = <List<List<num>?>>[
|
||||
var tests = [
|
||||
[
|
||||
[10, 10, 20, 20],
|
||||
[15, 15, 25, 25],
|
||||
|
|
@ -64,19 +63,19 @@ testIntersection() {
|
|||
];
|
||||
|
||||
for (var test in tests) {
|
||||
var r0 = createRectangle(test[0]);
|
||||
var r1 = createRectangle(test[1]);
|
||||
var r0 = createRectangle(test[0])!;
|
||||
var r1 = createRectangle(test[1])!;
|
||||
var expected = createRectangle(test[2]);
|
||||
|
||||
Expect.equals(expected, r0?.intersection(r1!));
|
||||
Expect.equals(expected, r1?.intersection(r0!));
|
||||
Expect.equals(expected, r0.intersection(r1));
|
||||
Expect.equals(expected, r1.intersection(r0));
|
||||
}
|
||||
}
|
||||
|
||||
testIntersects() {
|
||||
var r0 = new Rectangle(10, 10, 20, 20);
|
||||
var r1 = new Rectangle(15, 15, 25, 25);
|
||||
var r2 = new Rectangle(0, 0, 1, 1);
|
||||
var r0 = Rectangle(10, 10, 20, 20);
|
||||
var r1 = Rectangle(15, 15, 25, 25);
|
||||
var r2 = Rectangle(0, 0, 1, 1);
|
||||
|
||||
Expect.isTrue(r0.intersects(r1));
|
||||
Expect.isTrue(r1.intersects(r0));
|
||||
|
|
@ -110,75 +109,75 @@ testBoundingBox() {
|
|||
];
|
||||
|
||||
for (var test in tests) {
|
||||
var r0 = createRectangle(test[0]);
|
||||
var r1 = createRectangle(test[1]);
|
||||
var expected = createRectangle(test[2]);
|
||||
var r0 = createRectangle(test[0])!;
|
||||
var r1 = createRectangle(test[1])!;
|
||||
var expected = createRectangle(test[2])!;
|
||||
|
||||
Expect.equals(expected, r0?.boundingBox(r1!));
|
||||
Expect.equals(expected, r1?.boundingBox(r0!));
|
||||
Expect.equals(expected, r0.boundingBox(r1));
|
||||
Expect.equals(expected, r1.boundingBox(r0));
|
||||
}
|
||||
}
|
||||
|
||||
testContainsRectangle() {
|
||||
var r = new Rectangle(-10, 0, 20, 10);
|
||||
var r = Rectangle(-10, 0, 20, 10);
|
||||
Expect.isTrue(r.containsRectangle(r));
|
||||
|
||||
Expect.isFalse(r.containsRectangle(
|
||||
new Rectangle(double.nan, double.nan, double.nan, double.nan)));
|
||||
Rectangle(double.nan, double.nan, double.nan, double.nan)));
|
||||
|
||||
var r2 = new Rectangle(0, 2, 5, 5);
|
||||
var r2 = Rectangle(0, 2, 5, 5);
|
||||
Expect.isTrue(r.containsRectangle(r2));
|
||||
Expect.isFalse(r2.containsRectangle(r));
|
||||
|
||||
r2 = new Rectangle(-11, 2, 5, 5);
|
||||
r2 = Rectangle(-11, 2, 5, 5);
|
||||
Expect.isFalse(r.containsRectangle(r2));
|
||||
r2 = new Rectangle(0, 2, 15, 5);
|
||||
r2 = Rectangle(0, 2, 15, 5);
|
||||
Expect.isFalse(r.containsRectangle(r2));
|
||||
r2 = new Rectangle(0, 2, 5, 10);
|
||||
r2 = Rectangle(0, 2, 5, 10);
|
||||
Expect.isFalse(r.containsRectangle(r2));
|
||||
r2 = new Rectangle(0, 0, 5, 10);
|
||||
r2 = Rectangle(0, 0, 5, 10);
|
||||
Expect.isTrue(r.containsRectangle(r2));
|
||||
}
|
||||
|
||||
testContainsPoint() {
|
||||
var r = new Rectangle(20, 40, 60, 80);
|
||||
var r = Rectangle(20, 40, 60, 80);
|
||||
|
||||
// Test middle.
|
||||
Expect.isTrue(r.containsPoint(new Point(50, 80)));
|
||||
Expect.isTrue(r.containsPoint(Point(50, 80)));
|
||||
|
||||
// Test edges.
|
||||
Expect.isTrue(r.containsPoint(new Point(20, 40)));
|
||||
Expect.isTrue(r.containsPoint(new Point(50, 40)));
|
||||
Expect.isTrue(r.containsPoint(new Point(80, 40)));
|
||||
Expect.isTrue(r.containsPoint(new Point(80, 80)));
|
||||
Expect.isTrue(r.containsPoint(new Point(80, 120)));
|
||||
Expect.isTrue(r.containsPoint(new Point(50, 120)));
|
||||
Expect.isTrue(r.containsPoint(new Point(20, 120)));
|
||||
Expect.isTrue(r.containsPoint(new Point(20, 80)));
|
||||
Expect.isTrue(r.containsPoint(Point(20, 40)));
|
||||
Expect.isTrue(r.containsPoint(Point(50, 40)));
|
||||
Expect.isTrue(r.containsPoint(Point(80, 40)));
|
||||
Expect.isTrue(r.containsPoint(Point(80, 80)));
|
||||
Expect.isTrue(r.containsPoint(Point(80, 120)));
|
||||
Expect.isTrue(r.containsPoint(Point(50, 120)));
|
||||
Expect.isTrue(r.containsPoint(Point(20, 120)));
|
||||
Expect.isTrue(r.containsPoint(Point(20, 80)));
|
||||
|
||||
// Test outside.
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 0)));
|
||||
Expect.isFalse(r.containsPoint(new Point(50, 0)));
|
||||
Expect.isFalse(r.containsPoint(new Point(100, 0)));
|
||||
Expect.isFalse(r.containsPoint(new Point(100, 80)));
|
||||
Expect.isFalse(r.containsPoint(new Point(100, 160)));
|
||||
Expect.isFalse(r.containsPoint(new Point(50, 160)));
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 160)));
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 80)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 0)));
|
||||
Expect.isFalse(r.containsPoint(Point(50, 0)));
|
||||
Expect.isFalse(r.containsPoint(Point(100, 0)));
|
||||
Expect.isFalse(r.containsPoint(Point(100, 80)));
|
||||
Expect.isFalse(r.containsPoint(Point(100, 160)));
|
||||
Expect.isFalse(r.containsPoint(Point(50, 160)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 160)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 80)));
|
||||
}
|
||||
|
||||
testHashCode() {
|
||||
var a = new Rectangle(0, 1, 2, 3);
|
||||
var b = new Rectangle(0, 1, 2, 3);
|
||||
var a = Rectangle(0, 1, 2, 3);
|
||||
var b = Rectangle(0, 1, 2, 3);
|
||||
Expect.equals(b.hashCode, a.hashCode);
|
||||
|
||||
var c = new Rectangle(1, 0, 2, 3);
|
||||
var c = Rectangle(1, 0, 2, 3);
|
||||
Expect.isFalse(a.hashCode == c.hashCode);
|
||||
}
|
||||
|
||||
testEdgeCases() {
|
||||
edgeTest(double a, double l) {
|
||||
var r = new Rectangle(a, a, l, l);
|
||||
var r = Rectangle(a, a, l, l);
|
||||
Expect.equals(r, r.boundingBox(r));
|
||||
Expect.equals(r, r.intersection(r));
|
||||
}
|
||||
|
|
@ -196,8 +195,8 @@ testEdgeCases() {
|
|||
|
||||
testEquality() {
|
||||
var bignum = 0x80000000000008 + 0.0;
|
||||
var r1 = new Rectangle(bignum, bignum, 1.0, 1.0);
|
||||
var r2 = new Rectangle(bignum, bignum, 2.0, 2.0);
|
||||
var r1 = Rectangle(bignum, bignum, 1.0, 1.0);
|
||||
var r2 = Rectangle(bignum, bignum, 2.0, 2.0);
|
||||
Expect.equals(r2, r1);
|
||||
Expect.equals(r2.hashCode, r1.hashCode);
|
||||
Expect.equals(r2.right, r1.right);
|
||||
|
|
@ -208,17 +207,22 @@ testEquality() {
|
|||
|
||||
testNegativeLengths() {
|
||||
// Constructor allows negative lengths, but clamps them to zero.
|
||||
Expect.equals(new Rectangle(4, 4, 0, 0), new Rectangle(4, 4, -2, -2));
|
||||
Expect.equals(new Rectangle(4, 4, 0, 0), new MutableRectangle(4, 4, -2, -2));
|
||||
Expect.equals(Rectangle(4, 4, 0, 0), Rectangle(4, 4, -2, -2));
|
||||
Expect.equals(Rectangle(4, 4, 0, 0), MutableRectangle(4, 4, -2, -2));
|
||||
|
||||
// Setters clamp negative lengths to zero.
|
||||
var mutable = new MutableRectangle(0, 0, 1, 1);
|
||||
var mutable = MutableRectangle(0, 0, 1, 1);
|
||||
mutable.width = -1;
|
||||
mutable.height = -1;
|
||||
Expect.equals(new Rectangle(0, 0, 0, 0), mutable);
|
||||
Expect.equals(Rectangle(0, 0, 0, 0), mutable);
|
||||
|
||||
// Test that doubles are clamped to double zero.
|
||||
var rectangle = new Rectangle(1.5, 1.5, -2.5, -2.5);
|
||||
var rectangle = Rectangle(1.5, 1.5, -2.5, -2.5);
|
||||
Expect.isTrue(identical(rectangle.width, 0.0));
|
||||
Expect.isTrue(identical(rectangle.height, 0.0));
|
||||
|
||||
var inf = double.infinity;
|
||||
rectangle = Rectangle(1.5, 1.5, -inf, -inf);
|
||||
Expect.isTrue(identical(rectangle.width, 0.0));
|
||||
Expect.isTrue(identical(rectangle.height, 0.0));
|
||||
}
|
||||
|
|
@ -226,14 +230,14 @@ testNegativeLengths() {
|
|||
testNaNLeft() {
|
||||
var rectangles = [
|
||||
const Rectangle(double.nan, 1, 2, 3),
|
||||
new MutableRectangle(double.nan, 1, 2, 3),
|
||||
new Rectangle.fromPoints(new Point(double.nan, 1), new Point(2, 4)),
|
||||
new MutableRectangle.fromPoints(new Point(double.nan, 1), new Point(2, 4)),
|
||||
MutableRectangle(double.nan, 1, 2, 3),
|
||||
Rectangle.fromPoints(Point(double.nan, 1), Point(2, 4)),
|
||||
MutableRectangle.fromPoints(Point(double.nan, 1), Point(2, 4)),
|
||||
];
|
||||
for (var r in rectangles) {
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isTrue(r.left.isNaN);
|
||||
Expect.isTrue(r.right.isNaN);
|
||||
}
|
||||
|
|
@ -242,14 +246,14 @@ testNaNLeft() {
|
|||
testNaNTop() {
|
||||
var rectangles = [
|
||||
const Rectangle(0, double.nan, 2, 3),
|
||||
new MutableRectangle(0, double.nan, 2, 3),
|
||||
new Rectangle.fromPoints(new Point(0, double.nan), new Point(2, 4)),
|
||||
new MutableRectangle.fromPoints(new Point(0, double.nan), new Point(2, 4)),
|
||||
MutableRectangle(0, double.nan, 2, 3),
|
||||
Rectangle.fromPoints(Point(0, double.nan), Point(2, 4)),
|
||||
MutableRectangle.fromPoints(Point(0, double.nan), Point(2, 4)),
|
||||
];
|
||||
for (var r in rectangles) {
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isTrue(r.top.isNaN);
|
||||
Expect.isTrue(r.bottom.isNaN);
|
||||
}
|
||||
|
|
@ -258,14 +262,14 @@ testNaNTop() {
|
|||
testNaNWidth() {
|
||||
var rectangles = [
|
||||
const Rectangle(0, 1, double.nan, 3),
|
||||
new MutableRectangle(0, 1, double.nan, 3),
|
||||
new Rectangle.fromPoints(new Point(0, 1), new Point(double.nan, 4)),
|
||||
new MutableRectangle.fromPoints(new Point(0, 1), new Point(double.nan, 4)),
|
||||
MutableRectangle(0, 1, double.nan, 3),
|
||||
Rectangle.fromPoints(Point(0, 1), Point(double.nan, 4)),
|
||||
MutableRectangle.fromPoints(Point(0, 1), Point(double.nan, 4)),
|
||||
];
|
||||
for (var r in rectangles) {
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isTrue(r.right.isNaN);
|
||||
Expect.isTrue(r.width.isNaN);
|
||||
}
|
||||
|
|
@ -274,14 +278,14 @@ testNaNWidth() {
|
|||
testNaNHeight() {
|
||||
var rectangles = [
|
||||
const Rectangle(0, 1, 2, double.nan),
|
||||
new MutableRectangle(0, 1, 2, double.nan),
|
||||
new Rectangle.fromPoints(new Point(0, 1), new Point(2, double.nan)),
|
||||
new MutableRectangle.fromPoints(new Point(0, 1), new Point(2, double.nan)),
|
||||
MutableRectangle(0, 1, 2, double.nan),
|
||||
Rectangle.fromPoints(Point(0, 1), Point(2, double.nan)),
|
||||
MutableRectangle.fromPoints(Point(0, 1), Point(2, double.nan)),
|
||||
];
|
||||
for (var r in rectangles) {
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isTrue(r.bottom.isNaN);
|
||||
Expect.isTrue(r.height.isNaN);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,20 +24,19 @@ main() {
|
|||
testNaNHeight();
|
||||
}
|
||||
|
||||
Rectangle createRectangle(List<num> a) {
|
||||
return a != null ? new Rectangle(a[0], a[1], a[2] - a[0], a[3] - a[1]) : null;
|
||||
}
|
||||
Rectangle createRectangle(List<num> a) =>
|
||||
a != null ? Rectangle(a[0], a[1], a[2] - a[0], a[3] - a[1]) : null;
|
||||
|
||||
testConstruction() {
|
||||
var r0 = new Rectangle(10, 20, 30, 40);
|
||||
var r0 = Rectangle(10, 20, 30, 40);
|
||||
Expect.equals('Rectangle (10, 20) 30 x 40', r0.toString());
|
||||
Expect.equals(40, r0.right);
|
||||
Expect.equals(60, r0.bottom);
|
||||
|
||||
var r1 = new Rectangle.fromPoints(r0.topLeft, r0.bottomRight);
|
||||
var r1 = Rectangle.fromPoints(r0.topLeft, r0.bottomRight);
|
||||
Expect.equals(r0, r1);
|
||||
|
||||
var r2 = new Rectangle.fromPoints(r0.bottomRight, r0.topLeft);
|
||||
var r2 = Rectangle.fromPoints(r0.bottomRight, r0.topLeft);
|
||||
Expect.equals(r0, r2);
|
||||
}
|
||||
|
||||
|
|
@ -76,9 +75,9 @@ testIntersection() {
|
|||
}
|
||||
|
||||
testIntersects() {
|
||||
var r0 = new Rectangle(10, 10, 20, 20);
|
||||
var r1 = new Rectangle(15, 15, 25, 25);
|
||||
var r2 = new Rectangle(0, 0, 1, 1);
|
||||
var r0 = Rectangle(10, 10, 20, 20);
|
||||
var r1 = Rectangle(15, 15, 25, 25);
|
||||
var r2 = Rectangle(0, 0, 1, 1);
|
||||
|
||||
Expect.isTrue(r0.intersects(r1));
|
||||
Expect.isTrue(r1.intersects(r0));
|
||||
|
|
@ -122,65 +121,65 @@ testBoundingBox() {
|
|||
}
|
||||
|
||||
testContainsRectangle() {
|
||||
var r = new Rectangle(-10, 0, 20, 10);
|
||||
var r = Rectangle(-10, 0, 20, 10);
|
||||
Expect.isTrue(r.containsRectangle(r));
|
||||
|
||||
Expect.isFalse(r.containsRectangle(
|
||||
new Rectangle(double.nan, double.nan, double.nan, double.nan)));
|
||||
Rectangle(double.nan, double.nan, double.nan, double.nan)));
|
||||
|
||||
var r2 = new Rectangle(0, 2, 5, 5);
|
||||
var r2 = Rectangle(0, 2, 5, 5);
|
||||
Expect.isTrue(r.containsRectangle(r2));
|
||||
Expect.isFalse(r2.containsRectangle(r));
|
||||
|
||||
r2 = new Rectangle(-11, 2, 5, 5);
|
||||
r2 = Rectangle(-11, 2, 5, 5);
|
||||
Expect.isFalse(r.containsRectangle(r2));
|
||||
r2 = new Rectangle(0, 2, 15, 5);
|
||||
r2 = Rectangle(0, 2, 15, 5);
|
||||
Expect.isFalse(r.containsRectangle(r2));
|
||||
r2 = new Rectangle(0, 2, 5, 10);
|
||||
r2 = Rectangle(0, 2, 5, 10);
|
||||
Expect.isFalse(r.containsRectangle(r2));
|
||||
r2 = new Rectangle(0, 0, 5, 10);
|
||||
r2 = Rectangle(0, 0, 5, 10);
|
||||
Expect.isTrue(r.containsRectangle(r2));
|
||||
}
|
||||
|
||||
testContainsPoint() {
|
||||
var r = new Rectangle(20, 40, 60, 80);
|
||||
var r = Rectangle(20, 40, 60, 80);
|
||||
|
||||
// Test middle.
|
||||
Expect.isTrue(r.containsPoint(new Point(50, 80)));
|
||||
Expect.isTrue(r.containsPoint(Point(50, 80)));
|
||||
|
||||
// Test edges.
|
||||
Expect.isTrue(r.containsPoint(new Point(20, 40)));
|
||||
Expect.isTrue(r.containsPoint(new Point(50, 40)));
|
||||
Expect.isTrue(r.containsPoint(new Point(80, 40)));
|
||||
Expect.isTrue(r.containsPoint(new Point(80, 80)));
|
||||
Expect.isTrue(r.containsPoint(new Point(80, 120)));
|
||||
Expect.isTrue(r.containsPoint(new Point(50, 120)));
|
||||
Expect.isTrue(r.containsPoint(new Point(20, 120)));
|
||||
Expect.isTrue(r.containsPoint(new Point(20, 80)));
|
||||
Expect.isTrue(r.containsPoint(Point(20, 40)));
|
||||
Expect.isTrue(r.containsPoint(Point(50, 40)));
|
||||
Expect.isTrue(r.containsPoint(Point(80, 40)));
|
||||
Expect.isTrue(r.containsPoint(Point(80, 80)));
|
||||
Expect.isTrue(r.containsPoint(Point(80, 120)));
|
||||
Expect.isTrue(r.containsPoint(Point(50, 120)));
|
||||
Expect.isTrue(r.containsPoint(Point(20, 120)));
|
||||
Expect.isTrue(r.containsPoint(Point(20, 80)));
|
||||
|
||||
// Test outside.
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 0)));
|
||||
Expect.isFalse(r.containsPoint(new Point(50, 0)));
|
||||
Expect.isFalse(r.containsPoint(new Point(100, 0)));
|
||||
Expect.isFalse(r.containsPoint(new Point(100, 80)));
|
||||
Expect.isFalse(r.containsPoint(new Point(100, 160)));
|
||||
Expect.isFalse(r.containsPoint(new Point(50, 160)));
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 160)));
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 80)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 0)));
|
||||
Expect.isFalse(r.containsPoint(Point(50, 0)));
|
||||
Expect.isFalse(r.containsPoint(Point(100, 0)));
|
||||
Expect.isFalse(r.containsPoint(Point(100, 80)));
|
||||
Expect.isFalse(r.containsPoint(Point(100, 160)));
|
||||
Expect.isFalse(r.containsPoint(Point(50, 160)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 160)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 80)));
|
||||
}
|
||||
|
||||
testHashCode() {
|
||||
var a = new Rectangle(0, 1, 2, 3);
|
||||
var b = new Rectangle(0, 1, 2, 3);
|
||||
var a = Rectangle(0, 1, 2, 3);
|
||||
var b = Rectangle(0, 1, 2, 3);
|
||||
Expect.equals(b.hashCode, a.hashCode);
|
||||
|
||||
var c = new Rectangle(1, 0, 2, 3);
|
||||
var c = Rectangle(1, 0, 2, 3);
|
||||
Expect.isFalse(a.hashCode == c.hashCode);
|
||||
}
|
||||
|
||||
testEdgeCases() {
|
||||
edgeTest(double a, double l) {
|
||||
var r = new Rectangle(a, a, l, l);
|
||||
var r = Rectangle(a, a, l, l);
|
||||
Expect.equals(r, r.boundingBox(r));
|
||||
Expect.equals(r, r.intersection(r));
|
||||
}
|
||||
|
|
@ -198,8 +197,8 @@ testEdgeCases() {
|
|||
|
||||
testEquality() {
|
||||
var bignum = 0x80000000000008 + 0.0;
|
||||
var r1 = new Rectangle(bignum, bignum, 1.0, 1.0);
|
||||
var r2 = new Rectangle(bignum, bignum, 2.0, 2.0);
|
||||
var r1 = Rectangle(bignum, bignum, 1.0, 1.0);
|
||||
var r2 = Rectangle(bignum, bignum, 2.0, 2.0);
|
||||
Expect.equals(r2, r1);
|
||||
Expect.equals(r2.hashCode, r1.hashCode);
|
||||
Expect.equals(r2.right, r1.right);
|
||||
|
|
@ -210,17 +209,22 @@ testEquality() {
|
|||
|
||||
testNegativeLengths() {
|
||||
// Constructor allows negative lengths, but clamps them to zero.
|
||||
Expect.equals(new Rectangle(4, 4, 0, 0), new Rectangle(4, 4, -2, -2));
|
||||
Expect.equals(new Rectangle(4, 4, 0, 0), new MutableRectangle(4, 4, -2, -2));
|
||||
Expect.equals(Rectangle(4, 4, 0, 0), Rectangle(4, 4, -2, -2));
|
||||
Expect.equals(Rectangle(4, 4, 0, 0), MutableRectangle(4, 4, -2, -2));
|
||||
|
||||
// Setters clamp negative lengths to zero.
|
||||
var mutable = new MutableRectangle(0, 0, 1, 1);
|
||||
var mutable = MutableRectangle(0, 0, 1, 1);
|
||||
mutable.width = -1;
|
||||
mutable.height = -1;
|
||||
Expect.equals(new Rectangle(0, 0, 0, 0), mutable);
|
||||
Expect.equals(Rectangle(0, 0, 0, 0), mutable);
|
||||
|
||||
// Test that doubles are clamped to double zero.
|
||||
var rectangle = new Rectangle(1.5, 1.5, -2.5, -2.5);
|
||||
var rectangle = Rectangle(1.5, 1.5, -2.5, -2.5);
|
||||
Expect.isTrue(identical(rectangle.width, 0.0));
|
||||
Expect.isTrue(identical(rectangle.height, 0.0));
|
||||
|
||||
var inf = double.infinity;
|
||||
rectangle = Rectangle(1.5, 1.5, -inf, -inf);
|
||||
Expect.isTrue(identical(rectangle.width, 0.0));
|
||||
Expect.isTrue(identical(rectangle.height, 0.0));
|
||||
}
|
||||
|
|
@ -228,14 +232,14 @@ testNegativeLengths() {
|
|||
testNaNLeft() {
|
||||
var rectangles = [
|
||||
const Rectangle(double.nan, 1, 2, 3),
|
||||
new MutableRectangle(double.nan, 1, 2, 3),
|
||||
new Rectangle.fromPoints(new Point(double.nan, 1), new Point(2, 4)),
|
||||
new MutableRectangle.fromPoints(new Point(double.nan, 1), new Point(2, 4)),
|
||||
MutableRectangle(double.nan, 1, 2, 3),
|
||||
Rectangle.fromPoints(Point(double.nan, 1), Point(2, 4)),
|
||||
MutableRectangle.fromPoints(Point(double.nan, 1), Point(2, 4)),
|
||||
];
|
||||
for (var r in rectangles) {
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isTrue(r.left.isNaN);
|
||||
Expect.isTrue(r.right.isNaN);
|
||||
}
|
||||
|
|
@ -244,14 +248,14 @@ testNaNLeft() {
|
|||
testNaNTop() {
|
||||
var rectangles = [
|
||||
const Rectangle(0, double.nan, 2, 3),
|
||||
new MutableRectangle(0, double.nan, 2, 3),
|
||||
new Rectangle.fromPoints(new Point(0, double.nan), new Point(2, 4)),
|
||||
new MutableRectangle.fromPoints(new Point(0, double.nan), new Point(2, 4)),
|
||||
MutableRectangle(0, double.nan, 2, 3),
|
||||
Rectangle.fromPoints(Point(0, double.nan), Point(2, 4)),
|
||||
MutableRectangle.fromPoints(Point(0, double.nan), Point(2, 4)),
|
||||
];
|
||||
for (var r in rectangles) {
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isTrue(r.top.isNaN);
|
||||
Expect.isTrue(r.bottom.isNaN);
|
||||
}
|
||||
|
|
@ -260,14 +264,14 @@ testNaNTop() {
|
|||
testNaNWidth() {
|
||||
var rectangles = [
|
||||
const Rectangle(0, 1, double.nan, 3),
|
||||
new MutableRectangle(0, 1, double.nan, 3),
|
||||
new Rectangle.fromPoints(new Point(0, 1), new Point(double.nan, 4)),
|
||||
new MutableRectangle.fromPoints(new Point(0, 1), new Point(double.nan, 4)),
|
||||
MutableRectangle(0, 1, double.nan, 3),
|
||||
Rectangle.fromPoints(Point(0, 1), Point(double.nan, 4)),
|
||||
MutableRectangle.fromPoints(Point(0, 1), Point(double.nan, 4)),
|
||||
];
|
||||
for (var r in rectangles) {
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isTrue(r.right.isNaN);
|
||||
Expect.isTrue(r.width.isNaN);
|
||||
}
|
||||
|
|
@ -276,14 +280,14 @@ testNaNWidth() {
|
|||
testNaNHeight() {
|
||||
var rectangles = [
|
||||
const Rectangle(0, 1, 2, double.nan),
|
||||
new MutableRectangle(0, 1, 2, double.nan),
|
||||
new Rectangle.fromPoints(new Point(0, 1), new Point(2, double.nan)),
|
||||
new MutableRectangle.fromPoints(new Point(0, 1), new Point(2, double.nan)),
|
||||
MutableRectangle(0, 1, 2, double.nan),
|
||||
Rectangle.fromPoints(Point(0, 1), Point(2, double.nan)),
|
||||
MutableRectangle.fromPoints(Point(0, 1), Point(2, double.nan)),
|
||||
];
|
||||
for (var r in rectangles) {
|
||||
Expect.isFalse(r.containsPoint(new Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(new Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.containsPoint(Point(0, 1)));
|
||||
Expect.isFalse(r.containsRectangle(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isFalse(r.intersects(Rectangle(0, 1, 2, 3)));
|
||||
Expect.isTrue(r.bottom.isNaN);
|
||||
Expect.isTrue(r.height.isNaN);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue