mirror of
https://github.com/gui-cs/Terminal.Gui.git
synced 2025-12-26 15:57:56 +01:00
2147 lines
71 KiB
C#
2147 lines
71 KiB
C#
namespace Terminal.Gui.DrawingTests;
|
|
|
|
|
|
|
|
public class RegionTests
|
|
{
|
|
[Fact]
|
|
public void Constructor_EmptyRegion_IsEmpty ()
|
|
{
|
|
var region = new Region ();
|
|
Assert.True (region.IsEmpty ());
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_WithRectangle_IsNotEmpty ()
|
|
{
|
|
var region = new Region (new Rectangle (10, 10, 50, 50));
|
|
Assert.False (region.IsEmpty ());
|
|
}
|
|
|
|
[Fact]
|
|
public void Union_Rectangle_AddsToRegion ()
|
|
{
|
|
var region = new Region ();
|
|
region.Union (new Rectangle (10, 10, 50, 50));
|
|
Assert.False (region.IsEmpty ());
|
|
Assert.True (region.Contains (20, 20));
|
|
}
|
|
|
|
[Fact]
|
|
public void Union_Region_MergesRegions ()
|
|
{
|
|
var region1 = new Region (new Rectangle (10, 10, 50, 50));
|
|
var region2 = new Region (new Rectangle (30, 30, 50, 50));
|
|
region1.Union (region2);
|
|
Assert.True (region1.Contains (20, 20));
|
|
Assert.True (region1.Contains (40, 40));
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_Rectangle_IntersectsRegion ()
|
|
{
|
|
var region = new Region (new Rectangle (10, 10, 50, 50));
|
|
region.Intersect (new Rectangle (30, 30, 50, 50));
|
|
Assert.False (region.Contains (20, 20));
|
|
Assert.True (region.Contains (40, 40));
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_Region_IntersectsRegions ()
|
|
{
|
|
var region1 = new Region (new Rectangle (10, 10, 50, 50));
|
|
var region2 = new Region (new Rectangle (30, 30, 50, 50));
|
|
region1.Intersect (region2);
|
|
Assert.False (region1.Contains (20, 20));
|
|
Assert.True (region1.Contains (40, 40));
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_Rectangle_ExcludesFromRegion ()
|
|
{
|
|
var region = new Region (new Rectangle (10, 10, 50, 50));
|
|
region.Exclude (new Rectangle (20, 20, 20, 20));
|
|
Assert.False (region.Contains (25, 25));
|
|
Assert.True (region.Contains (15, 15));
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_Region_ExcludesRegions ()
|
|
{
|
|
var region1 = new Region (new Rectangle (10, 10, 50, 50));
|
|
var region2 = new Region (new Rectangle (20, 20, 20, 20));
|
|
region1.Exclude (region2);
|
|
Assert.False (region1.Contains (25, 25));
|
|
Assert.True (region1.Contains (15, 15));
|
|
}
|
|
|
|
[Fact]
|
|
public void Complement_Rectangle_ComplementsRegion ()
|
|
{
|
|
var region = new Region (new Rectangle (10, 10, 50, 50));
|
|
region.Complement (new Rectangle (0, 0, 100, 100));
|
|
Assert.True (region.Contains (5, 5));
|
|
Assert.False (region.Contains (20, 20));
|
|
}
|
|
|
|
[Fact]
|
|
public void Clone_CreatesExactCopy ()
|
|
{
|
|
var region = new Region (new Rectangle (10, 10, 50, 50));
|
|
var clone = region.Clone ();
|
|
Assert.True (clone.Contains (20, 20));
|
|
Assert.Equal (region.GetRegionScans (), clone.GetRegionScans ());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetBounds_ReturnsBoundingRectangle ()
|
|
{
|
|
var region = new Region (new Rectangle (10, 10, 50, 50));
|
|
region.Union (new Rectangle (100, 100, 20, 20));
|
|
var bounds = region.GetBounds ();
|
|
Assert.Equal (new Rectangle (10, 10, 110, 110), bounds);
|
|
}
|
|
|
|
[Fact]
|
|
public void IsEmpty_EmptyRegion_ReturnsTrue ()
|
|
{
|
|
var region = new Region ();
|
|
Assert.True (region.IsEmpty ());
|
|
}
|
|
|
|
[Fact]
|
|
public void Contains_PointInsideRegion_ReturnsTrue ()
|
|
{
|
|
var region = new Region (new Rectangle (10, 10, 50, 50));
|
|
Assert.True (region.Contains (20, 20));
|
|
}
|
|
|
|
[Fact]
|
|
public void Contains_RectangleInsideRegion_ReturnsTrue ()
|
|
{
|
|
var region = new Region (new Rectangle (10, 10, 50, 50));
|
|
Assert.True (region.Contains (new Rectangle (20, 20, 10, 10)));
|
|
}
|
|
|
|
[Fact]
|
|
public void GetRegionScans_ReturnsAllRectangles ()
|
|
{
|
|
var region = new Region (new Rectangle (10, 10, 50, 50));
|
|
region.Union (new Rectangle (100, 100, 20, 20));
|
|
var scans = region.GetRegionScans ();
|
|
Assert.Equal (2, scans.Length);
|
|
Assert.Contains (new Rectangle (10, 10, 50, 50), scans);
|
|
Assert.Contains (new Rectangle (100, 100, 20, 20), scans);
|
|
}
|
|
[Fact]
|
|
public void Union_WithRectangle_AddsRectangle ()
|
|
{
|
|
var region = new Region ();
|
|
var rect = new Rectangle (10, 10, 50, 50);
|
|
|
|
region.Union (rect);
|
|
|
|
Assert.True (region.Contains (20, 20));
|
|
Assert.False (region.Contains (100, 100));
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_WithRectangle_IntersectsRectangles ()
|
|
{
|
|
var region = new Region (new (10, 10, 50, 50));
|
|
var rect = new Rectangle (30, 30, 50, 50);
|
|
|
|
region.Intersect (rect);
|
|
|
|
Assert.True (region.Contains (35, 35));
|
|
Assert.False (region.Contains (20, 20));
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_WithRectangle_ExcludesRectangle ()
|
|
{
|
|
var region = new Region (new (10, 10, 50, 50));
|
|
var rect = new Rectangle (30, 30, 50, 50);
|
|
|
|
region.Exclude (rect);
|
|
|
|
Assert.True (region.Contains (20, 20));
|
|
Assert.False (region.Contains (35, 35));
|
|
}
|
|
|
|
[Fact]
|
|
public void Contains_Point_ReturnsCorrectResult ()
|
|
{
|
|
var region = new Region (new (10, 10, 50, 50));
|
|
|
|
Assert.True (region.Contains (20, 20));
|
|
Assert.False (region.Contains (100, 100));
|
|
}
|
|
|
|
[Fact]
|
|
public void IsEmpty_ReturnsCorrectResult ()
|
|
{
|
|
var region = new Region ();
|
|
|
|
Assert.True (region.IsEmpty ());
|
|
|
|
region.Union (new Rectangle(10, 10, 50, 50));
|
|
|
|
Assert.False (region.IsEmpty ());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetBounds_ReturnsCorrectBounds ()
|
|
{
|
|
var region = new Region ();
|
|
region.Union (new Rectangle (10, 10, 50, 50));
|
|
region.Union (new Rectangle (30, 30, 50, 50));
|
|
|
|
Rectangle bounds = region.GetBounds ();
|
|
|
|
Assert.Equal (new (10, 10, 70, 70), bounds);
|
|
}
|
|
|
|
[Fact]
|
|
public void Dispose_ClearsRectangles ()
|
|
{
|
|
var region = new Region (new (10, 10, 50, 50));
|
|
region.Dispose ();
|
|
|
|
Assert.True (region.IsEmpty ());
|
|
}
|
|
|
|
[Fact]
|
|
public void Union_WithRegion_AddsRegion ()
|
|
{
|
|
var region1 = new Region (new (10, 10, 50, 50));
|
|
var region2 = new Region (new (30, 30, 50, 50));
|
|
|
|
region1.Union (region2.GetBounds ());
|
|
|
|
Assert.True (region1.Contains (20, 20));
|
|
Assert.True (region1.Contains (40, 40));
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_WithRegion_IntersectsRegions ()
|
|
{
|
|
var region1 = new Region (new (10, 10, 50, 50));
|
|
var region2 = new Region (new (30, 30, 50, 50));
|
|
|
|
region1.Intersect (region2.GetBounds ());
|
|
|
|
Assert.True (region1.Contains (35, 35));
|
|
Assert.False (region1.Contains (20, 20));
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_WithRegion_ExcludesRegion ()
|
|
{
|
|
var region1 = new Region (new (10, 10, 50, 50));
|
|
var region2 = new Region (new (30, 30, 50, 50));
|
|
|
|
region1.Exclude (region2.GetBounds ());
|
|
|
|
Assert.True (region1.Contains (20, 20));
|
|
Assert.False (region1.Contains (35, 35));
|
|
}
|
|
|
|
//[Fact]
|
|
//public void Complement_WithRectangle_ComplementsRegion ()
|
|
//{
|
|
// var region = new Region (new (10, 10, 50, 50));
|
|
// var rect = new Rectangle (30, 30, 50, 50);
|
|
|
|
// region.Complement (rect);
|
|
|
|
// Assert.True (region.Contains (35, 35));
|
|
// Assert.False (region.Contains (20, 20));
|
|
//}
|
|
|
|
//[Fact]
|
|
//public void Complement_WithRegion_ComplementsRegion ()
|
|
//{
|
|
// var region1 = new Region (new (10, 10, 50, 50));
|
|
// var region2 = new Region (new (30, 30, 50, 50));
|
|
|
|
// region1.Complement (region2.GetBounds ());
|
|
|
|
// Assert.True (region1.Contains (35, 35));
|
|
// Assert.False (region1.Contains (20, 20));
|
|
//}
|
|
|
|
private static Region CreateDisposedRegion ()
|
|
{
|
|
Region region = new ();
|
|
region.Dispose ();
|
|
|
|
return region;
|
|
}
|
|
|
|
public static IEnumerable<object []> Region_TestData ()
|
|
{
|
|
yield return new object [] { new Region () };
|
|
yield return new object [] { new Region (new Rectangle (0, 0, 0, 0)) };
|
|
yield return new object [] { new Region (new Rectangle (1, 2, 3, 4)) };
|
|
}
|
|
|
|
public static IEnumerable<object []> Complement_TestData ()
|
|
{
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (10, 10, 100, 100)),
|
|
new Rectangle [] { new (40, 60, 100, 20) },
|
|
new Rectangle [] { new (110, 60, 30, 20) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (70, 10, 100, 100)),
|
|
new Rectangle [] { new (40, 60, 100, 20) },
|
|
new Rectangle [] { new (40, 60, 30, 20) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (40, 100, 100, 100)),
|
|
new Rectangle [] { new (70, 80, 50, 40) },
|
|
new Rectangle [] { new (70, 80, 50, 20) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (40, 10, 100, 100)),
|
|
new Rectangle [] { new (70, 80, 50, 40) },
|
|
new Rectangle [] { new (70, 110, 50, 10) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (30, 30, 80, 80)),
|
|
new Rectangle []
|
|
{
|
|
new (45, 45, 200, 200),
|
|
new (160, 260, 10, 10),
|
|
new (170, 260, 10, 10),
|
|
},
|
|
new Rectangle [] { new (170, 260, 10, 10) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (),
|
|
new Rectangle [] { Rectangle.Empty },
|
|
new Rectangle[0]
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (),
|
|
new Rectangle [] { new (1, 2, 3, 4) },
|
|
new Rectangle[0]
|
|
};
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Complement_TestData))]
|
|
public void Complement_Region_Success (Region region, Rectangle [] rectangles, Rectangle [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (Rectangle rect in rectangles)
|
|
{
|
|
region.Complement (rect);
|
|
}
|
|
|
|
var actualScans = region.GetRegionScans ();
|
|
Assert.Equal (expectedScans, actualScans);
|
|
}
|
|
}
|
|
|
|
}
|
|
#if x
|
|
|
|
[Fact]
|
|
public void Complement_UnionRegion_Success ()
|
|
{
|
|
using Region region = new (new Rectangle (20, 20, 20, 20));
|
|
using Region other = new (new Rectangle (20, 80, 20, 10));
|
|
using Matrix matrix = new ();
|
|
other.Union (new Rectangle (60, 60, 30, 10));
|
|
|
|
region.Complement (other);
|
|
|
|
Assert.Equal (
|
|
[
|
|
new (60, 60, 30, 10),
|
|
new (20, 80, 20, 10)
|
|
],
|
|
region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Complement_InfiniteAndWithIntersectRegion_Success ()
|
|
{
|
|
using Region region = new ();
|
|
using Matrix matrix = new ();
|
|
region.Intersect (new Rectangle (5, 5, -10, -10));
|
|
region.Complement (new Rectangle (-5, -5, 12, 12));
|
|
|
|
Assert.False (region.IsEmpty (s_graphic));
|
|
Assert.False (region.IsInfinite (s_graphic));
|
|
|
|
Assert.Equal (
|
|
[
|
|
new (5, -5, 2, 10),
|
|
new (-5, 5, 12, 2)
|
|
],
|
|
region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Complement_InfiniteRegion_Success ()
|
|
{
|
|
using Region region = new (new Rectangle (1, 2, 3, 4));
|
|
using Matrix matrix = new ();
|
|
using Region other = new ();
|
|
region.Complement (other);
|
|
|
|
Assert.Equal (
|
|
[
|
|
new (-4194304, -4194304, 8388608, 4194306),
|
|
new (-4194304, 2, 4194305, 4),
|
|
new (4, 2, 4194300, 4),
|
|
new (-4194304, 6, 8388608, 4194298)
|
|
],
|
|
region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Complement_NullRegion_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("region", () => region.Complement ((Region)null));
|
|
}
|
|
|
|
|
|
[Fact]
|
|
public void Complement_SameRegion_ThrowsInvalidOperationException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<InvalidOperationException> (() => region.Complement (region));
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Complement_TestData))]
|
|
public void Complement_Rectangle_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
region.Complement (new Rectangle ((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height));
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Complement_TestData))]
|
|
public void Complement_RectangleF_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
region.Complement (rect);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Complement_TestData))]
|
|
public void Complement_GraphicsPath_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
using GraphicsPath path = new ();
|
|
path.AddRectangle (rect);
|
|
region.Complement (path);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Complement_GraphicsPathWithMultipleRectangles_Success ()
|
|
{
|
|
Rectangle rect1 = new (20, 30, 60, 80);
|
|
Rectangle rect2 = new (50, 40, 60, 80);
|
|
|
|
using Graphics graphics = Graphics.FromImage (new Bitmap (600, 800));
|
|
using Region region1 = new (rect1);
|
|
using Region region2 = new (rect2);
|
|
using Matrix matrix = new ();
|
|
graphics.DrawRectangle (Pens.Green, rect1);
|
|
graphics.DrawRectangle (Pens.Red, rect2);
|
|
|
|
region1.Complement (region2);
|
|
graphics.FillRegion (Brushes.Blue, region1);
|
|
graphics.DrawRectangles (Pens.Yellow, region1.GetRegionScans (matrix));
|
|
|
|
Assert.Equal (
|
|
[
|
|
new (80, 40, 30, 70),
|
|
new (50, 110, 60, 10)
|
|
],
|
|
region1.GetRegionScans (matrix));
|
|
}
|
|
|
|
|
|
public static IEnumerable<object []> Equals_TestData ()
|
|
{
|
|
static Region Empty ()
|
|
{
|
|
Region emptyRegion = new ();
|
|
emptyRegion.MakeEmpty ();
|
|
|
|
return emptyRegion;
|
|
}
|
|
|
|
Region createdRegion = new ();
|
|
|
|
yield return new object [] { createdRegion, createdRegion, true };
|
|
yield return new object [] { new Region (), new Region (), true };
|
|
yield return new object [] { new Region (), Empty (), false };
|
|
yield return new object [] { new Region (), new Region (new Rectangle (1, 2, 3, 4)), false };
|
|
|
|
yield return new object [] { Empty (), Empty (), true };
|
|
yield return new object [] { Empty (), new Region (new Rectangle (0, 0, 0, 0)), true };
|
|
yield return new object [] { Empty (), new Region (new Rectangle (1, 2, 3, 3)), false };
|
|
|
|
yield return new object [] { new Region (new Rectangle (1, 2, 3, 4)), new Region (new Rectangle (1, 2, 3, 4)), true };
|
|
yield return new object [] { new Region (new Rectangle (1, 2, 3, 4)), new Region (new RectangleF (1, 2, 3, 4)), true };
|
|
yield return new object [] { new Region (new Rectangle (1, 2, 3, 4)), new Region (new Rectangle (2, 2, 3, 4)), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 2, 3, 4)), new Region (new Rectangle (1, 3, 3, 4)), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 2, 3, 4)), new Region (new Rectangle (1, 2, 4, 4)), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 2, 3, 4)), new Region (new Rectangle (1, 2, 3, 5)), false };
|
|
|
|
GraphicsPath graphics1 = new ();
|
|
graphics1.AddRectangle (new Rectangle (1, 2, 3, 4));
|
|
|
|
GraphicsPath graphics2 = new ();
|
|
graphics2.AddRectangle (new Rectangle (1, 2, 3, 4));
|
|
|
|
GraphicsPath graphics3 = new ();
|
|
graphics3.AddRectangle (new Rectangle (2, 2, 3, 4));
|
|
|
|
GraphicsPath graphics4 = new ();
|
|
graphics4.AddRectangle (new Rectangle (1, 3, 3, 4));
|
|
|
|
GraphicsPath graphics5 = new ();
|
|
graphics5.AddRectangle (new Rectangle (1, 2, 4, 4));
|
|
|
|
GraphicsPath graphics6 = new ();
|
|
graphics6.AddRectangle (new Rectangle (1, 2, 3, 5));
|
|
|
|
yield return new object [] { new Region (graphics1), new Region (graphics1), true };
|
|
yield return new object [] { new Region (graphics1), new Region (graphics2), true };
|
|
yield return new object [] { new Region (graphics1), new Region (graphics3), false };
|
|
yield return new object [] { new Region (graphics1), new Region (graphics4), false };
|
|
yield return new object [] { new Region (graphics1), new Region (graphics5), false };
|
|
yield return new object [] { new Region (graphics1), new Region (graphics6), false };
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Equals_TestData))]
|
|
public void Equals_Valid_ReturnsExpected (Region region, Region other, bool expected)
|
|
{
|
|
using (region)
|
|
using (other)
|
|
{
|
|
Assert.Equal (expected, region.Equals (other, s_graphic));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Equals_NullRegion_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("region", () => region.Equals (null, s_graphic));
|
|
}
|
|
|
|
[Fact]
|
|
public void Equals_NullGraphics_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("g", () => region.Equals (region, null));
|
|
}
|
|
|
|
[Fact]
|
|
public void Equals_DisposedGraphics_ThrowsArgumentException ()
|
|
{
|
|
using Region region = new ();
|
|
using Region other = new ();
|
|
using Bitmap image = new (10, 10);
|
|
var graphics = Graphics.FromImage (image);
|
|
graphics.Dispose ();
|
|
Assert.Throws<ArgumentException> (null, () => region.Equals (region, graphics));
|
|
}
|
|
|
|
[Fact]
|
|
public void Equals_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Region disposedRegion = CreateDisposedRegion ();
|
|
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Equals (new Region (), s_graphic));
|
|
Assert.Throws<ArgumentException> (null, () => new Region ().Equals (disposedRegion, s_graphic));
|
|
}
|
|
|
|
public static IEnumerable<object []> Exclude_TestData ()
|
|
{
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (500, 30, 60, 80)),
|
|
new RectangleF [] { new (500, 30, 60, 80) },
|
|
new RectangleF[0]
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (500, 30, 60, 80)),
|
|
new RectangleF [] { RectangleF.Empty },
|
|
new RectangleF [] { new (500, 30, 60, 80) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (),
|
|
new RectangleF [] { new (520, 40, 60, 80) },
|
|
new RectangleF []
|
|
{
|
|
new (-4194304, -4194304, 8388608, 4194344),
|
|
new (-4194304, 40, 4194824, 80),
|
|
new (580, 40, 4193724, 80),
|
|
new (-4194304, 120, 8388608, 4194184)
|
|
}
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (),
|
|
new RectangleF [] { RectangleF.Empty },
|
|
new RectangleF [] { new Rectangle (-4194304, -4194304, 8388608, 8388608) }
|
|
};
|
|
|
|
// Intersecting from the right.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (10, 10, 100, 100)),
|
|
new RectangleF [] { new (40, 60, 100, 20) },
|
|
new RectangleF []
|
|
{
|
|
new (10, 10, 100, 50),
|
|
new (10, 60, 30, 20),
|
|
new (10, 80, 100, 30)
|
|
}
|
|
};
|
|
|
|
// Intersecting from the left.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (70, 10, 100, 100)),
|
|
new RectangleF [] { new (40, 60, 100, 20) },
|
|
new RectangleF []
|
|
{
|
|
new (70, 10, 100, 50),
|
|
new (140, 60, 30, 20),
|
|
new (70, 80, 100, 30)
|
|
}
|
|
};
|
|
|
|
// Intersecting from the top.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (40, 100, 100, 100)),
|
|
new RectangleF [] { new (70, 80, 50, 40) },
|
|
new RectangleF []
|
|
{
|
|
new (40, 100, 30, 20),
|
|
new (120, 100, 20, 20),
|
|
new (40, 120, 100, 80)
|
|
}
|
|
};
|
|
|
|
// Intersecting from the bottom.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (40, 10, 100, 100)),
|
|
new RectangleF [] { new (70, 80, 50, 40) },
|
|
new RectangleF []
|
|
{
|
|
new (40, 10, 100, 70),
|
|
new (40, 80, 30, 30),
|
|
new (120, 80, 20, 30)
|
|
}
|
|
};
|
|
|
|
// Multiple regions.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (30, 30, 80, 80)),
|
|
new RectangleF []
|
|
{
|
|
new (45, 45, 200, 200),
|
|
new (160, 260, 10, 10),
|
|
new (170, 260, 10, 10)
|
|
},
|
|
new RectangleF []
|
|
{
|
|
new (30, 30, 80, 15),
|
|
new (30, 45, 15, 65)
|
|
}
|
|
};
|
|
|
|
// Intersecting from the top with a larger rect.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (50, 100, 100, 100)),
|
|
new RectangleF [] { new (30, 70, 150, 40) },
|
|
new RectangleF [] { new (50, 110, 100, 90) }
|
|
};
|
|
|
|
// Intersecting from the right with a larger rect.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (70, 60, 100, 70)),
|
|
new RectangleF [] { new (40, 10, 100, 150) },
|
|
new RectangleF [] { new (140, 60, 30, 70) }
|
|
};
|
|
|
|
// Intersecting from the left with a larger rect.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (70, 60, 100, 70)),
|
|
new RectangleF [] { new (100, 10, 100, 150) },
|
|
new RectangleF [] { new (70, 60, 30, 70) }
|
|
};
|
|
|
|
// Intersecting from the bottom with a larger rect.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (20, 20, 100, 100)),
|
|
new RectangleF [] { new (10, 80, 140, 150) },
|
|
new RectangleF [] { new (20, 20, 100, 60) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (130, 30, 60, 80)),
|
|
new RectangleF [] { new (170, 40, 60, 80) },
|
|
new RectangleF []
|
|
{
|
|
new (130, 30, 60, 10),
|
|
new (130, 40, 40, 70)
|
|
}
|
|
};
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Exclude_TestData))]
|
|
public void Exclude_Region_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
using Region other = new (rect);
|
|
region.Exclude (other);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_UnionRegion_Success ()
|
|
{
|
|
using Region region = new (new RectangleF (20, 20, 20, 20));
|
|
using Region union = new (new RectangleF (20, 80, 20, 10));
|
|
using Matrix matrix = new ();
|
|
union.Union (new RectangleF (60, 60, 30, 10));
|
|
region.Exclude (union);
|
|
Assert.Equal ([new (20, 20, 20, 20)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_InfiniteRegion_Success ()
|
|
{
|
|
using Region region = new (new Rectangle (1, 2, 3, 4));
|
|
using Region other = new ();
|
|
using Matrix matrix = new ();
|
|
region.Exclude (other);
|
|
Assert.Equal ([], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_NullRegion_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("region", () => region.Exclude ((Region)null));
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_DisposedRegion_ThrowsArgumentException ()
|
|
{
|
|
Assert.Throws<ArgumentException> (null, () => new Region ().Exclude (CreateDisposedRegion ()));
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_SameRegion_ThrowsInvalidOperationException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<InvalidOperationException> (() => region.Exclude (region));
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Exclude_TestData))]
|
|
public void Exclude_Rectangle_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
region.Exclude (new Rectangle ((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height));
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Exclude_TestData))]
|
|
public void Exclude_RectangleF_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
region.Exclude (rect);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Exclude_TestData))]
|
|
public void Exclude_GraphicsPath_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
using GraphicsPath path = new ();
|
|
path.AddRectangle (rect);
|
|
region.Exclude (path);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_EmptyPathWithInfiniteRegion_MakesInfinite ()
|
|
{
|
|
using Region region = new ();
|
|
using GraphicsPath graphicsPath = new ();
|
|
region.Exclude (graphicsPath);
|
|
Assert.True (region.IsInfinite (s_graphic));
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_NullGraphicsPath_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("path", () => region.Exclude ((GraphicsPath)null));
|
|
}
|
|
|
|
[Fact]
|
|
public void Exclude_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Region disposedRegion = CreateDisposedRegion ();
|
|
|
|
using GraphicsPath graphicsPath = new ();
|
|
using Region other = new ();
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Exclude (graphicsPath));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Exclude (new Rectangle ()));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Exclude (new RectangleF ()));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Exclude (other));
|
|
}
|
|
|
|
[Fact]
|
|
public void FromHrgn_ValidHrgn_ReturnsExpected ()
|
|
{
|
|
using Region region = new (new Rectangle (1, 2, 3, 4));
|
|
IntPtr handle1 = region.GetHrgn (s_graphic);
|
|
IntPtr handle2 = region.GetHrgn (s_graphic);
|
|
Assert.NotEqual (IntPtr.Zero, handle1);
|
|
Assert.NotEqual (handle1, handle2);
|
|
|
|
Region newRegion = Region.FromHrgn (handle1);
|
|
IntPtr handle3 = newRegion.GetHrgn (s_graphic);
|
|
Assert.NotEqual (handle3, handle1);
|
|
Assert.Equal (new RectangleF (1, 2, 3, 4), newRegion.GetBounds (s_graphic));
|
|
|
|
region.ReleaseHrgn (handle1);
|
|
region.ReleaseHrgn (handle2);
|
|
newRegion.ReleaseHrgn (handle3);
|
|
}
|
|
|
|
[Fact]
|
|
public void FromHrgn_ZeroHrgn_ThrowsArgumentException () { Assert.Throws<ArgumentException> (null, () => Region.FromHrgn (IntPtr.Zero)); }
|
|
|
|
[Fact]
|
|
public void GetHrgn_Infinite_ReturnsZero ()
|
|
{
|
|
using Region region = new (new Rectangle (1, 2, 3, 4));
|
|
IntPtr handle = region.GetHrgn (s_graphic);
|
|
Assert.NotEqual (IntPtr.Zero, handle);
|
|
region.ReleaseHrgn (handle);
|
|
|
|
region.MakeInfinite ();
|
|
Assert.Equal (IntPtr.Zero, region.GetHrgn (s_graphic));
|
|
}
|
|
|
|
[Fact]
|
|
public void GetHrgn_Empty_ReturnsNonZero ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Equal (IntPtr.Zero, region.GetHrgn (s_graphic));
|
|
|
|
region.MakeEmpty ();
|
|
IntPtr handle = region.GetHrgn (s_graphic);
|
|
Assert.NotEqual (IntPtr.Zero, handle);
|
|
region.ReleaseHrgn (handle);
|
|
}
|
|
|
|
[Fact]
|
|
public void GetHrgn_NullGraphics_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("g", () => region.GetHrgn (null));
|
|
}
|
|
|
|
[Fact]
|
|
public void GetHrgn_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Assert.Throws<ArgumentException> (null, () => CreateDisposedRegion ().GetHrgn (s_graphic));
|
|
}
|
|
|
|
[Fact]
|
|
public void ReleaseHrgn_ZeroHandle_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("regionHandle", () => region.ReleaseHrgn (IntPtr.Zero));
|
|
}
|
|
|
|
[Fact]
|
|
public void GetBounds_NullGraphics_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("g", () => region.GetBounds (null));
|
|
}
|
|
|
|
[Fact]
|
|
public void GetBounds_DisposedGraphics_ThrowsArgumentException ()
|
|
{
|
|
using Region region = new ();
|
|
using Bitmap image = new (10, 10);
|
|
var graphics = Graphics.FromImage (image);
|
|
graphics.Dispose ();
|
|
Assert.Throws<ArgumentException> (null, () => region.GetBounds (graphics));
|
|
}
|
|
|
|
[Fact]
|
|
public void GetBounds_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Assert.Throws<ArgumentException> (null, () => CreateDisposedRegion ().GetBounds (s_graphic));
|
|
}
|
|
|
|
[Fact]
|
|
public void GetRegionData_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Assert.Throws<ArgumentException> (null, () => CreateDisposedRegion ().GetRegionData ());
|
|
}
|
|
|
|
[Fact]
|
|
public void GetRegionScans_CustomMatrix_TransformsRegionScans ()
|
|
{
|
|
using Matrix matrix = new ();
|
|
using Region region = new (new Rectangle (1, 2, 3, 4));
|
|
using Matrix emptyMatrix = new ();
|
|
matrix.Translate (10, 11);
|
|
matrix.Scale (5, 6);
|
|
|
|
Assert.Equal ([new (1, 2, 3, 4)], region.GetRegionScans (emptyMatrix));
|
|
Assert.Equal ([new (15, 23, 15, 24)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void GetRegionScans_NullMatrix_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("matrix", () => region.GetRegionScans (null));
|
|
}
|
|
|
|
[Fact]
|
|
public void GetRegionScans_Disposed_ThrowsArgumentException ()
|
|
{
|
|
using Matrix matrix = new ();
|
|
Assert.Throws<ArgumentException> (null, () => CreateDisposedRegion ().GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void GetRegionScans_DisposedMatrix_ThrowsArgumentException ()
|
|
{
|
|
using Region region = new ();
|
|
Matrix matrix = new ();
|
|
matrix.Dispose ();
|
|
Assert.Throws<ArgumentException> (null, () => region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_SmallerRect_Success ()
|
|
{
|
|
using Region clipRegion = new ();
|
|
using Matrix matrix = new ();
|
|
Rectangle smaller = new (5, 5, -10, -10);
|
|
|
|
clipRegion.Intersect (smaller);
|
|
Assert.False (clipRegion.IsEmpty (s_graphic));
|
|
Assert.False (clipRegion.IsInfinite (s_graphic));
|
|
|
|
RectangleF [] rects = clipRegion.GetRegionScans (matrix);
|
|
Assert.Equal (1, rects.Length);
|
|
Assert.Equal (new RectangleF (-5, -5, 10, 10), rects [0]);
|
|
}
|
|
|
|
public static IEnumerable<object []> Intersect_TestData ()
|
|
{
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (500, 30, 60, 80)),
|
|
new RectangleF [] { new (500, 30, 60, 80) },
|
|
new RectangleF [] { new (500, 30, 60, 80) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (0, 0, 0, 0)),
|
|
new RectangleF [] { new (500, 30, 60, 80) },
|
|
new RectangleF[0]
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (500, 30, 60, 80)),
|
|
new RectangleF [] { RectangleF.Empty },
|
|
new RectangleF[0]
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (),
|
|
new RectangleF [] { new (520, 40, 60, 80) },
|
|
new RectangleF [] { new Rectangle (520, 40, 60, 80) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (),
|
|
new RectangleF [] { RectangleF.Empty },
|
|
new RectangleF[0]
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new RectangleF (260, 30, 60, 80)),
|
|
new RectangleF [] { new (290, 40, 60, 90) },
|
|
new RectangleF [] { new (290, 40, 30, 70) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new RectangleF (20, 330, 40, 50)),
|
|
new RectangleF []
|
|
{
|
|
new (50, 340, 40, 50),
|
|
new (70, 360, 30, 50),
|
|
new (80, 400, 30, 10)
|
|
},
|
|
new RectangleF[0]
|
|
};
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Intersect_TestData))]
|
|
public void Intersect_Region_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
using Region rectangleRegion = new (rect);
|
|
region.Intersect (rectangleRegion);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_InfiniteRegion_Success ()
|
|
{
|
|
using Region region = new (new Rectangle (1, 2, 3, 4));
|
|
using Matrix matrix = new ();
|
|
using Region infiniteRegion = new ();
|
|
region.Intersect (infiniteRegion);
|
|
|
|
Assert.Equal ([new Rectangle (1, 2, 3, 4)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_NullRegion_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("region", () => region.Intersect ((Region)null));
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_DisposedRegion_ThrowsArgumentException ()
|
|
{
|
|
Assert.Throws<ArgumentException> (null, () => new Region ().Intersect (CreateDisposedRegion ()));
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_SameRegion_ThrowsInvalidOperationException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<InvalidOperationException> (() => region.Intersect (region));
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Intersect_TestData))]
|
|
public void Intersect_Rectangle_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
region.Intersect (new Rectangle ((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height));
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_InfiniteRegionWithSmallerRectangle_Success ()
|
|
{
|
|
using Region region = new ();
|
|
using Matrix matrix = new ();
|
|
region.Intersect (new Rectangle (5, 5, -10, -10));
|
|
|
|
Assert.False (region.IsEmpty (s_graphic));
|
|
Assert.False (region.IsInfinite (s_graphic));
|
|
Assert.Equal ([new (-5, -5, 10, 10)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Intersect_TestData))]
|
|
public void Intersect_RectangleF_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
region.Intersect (rect);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_InfiniteRegionWithSmallerRectangleF_Success ()
|
|
{
|
|
using Region region = new ();
|
|
using Matrix matrix = new ();
|
|
region.Intersect (new RectangleF (5, 5, -10, -10));
|
|
|
|
Assert.False (region.IsEmpty (s_graphic));
|
|
Assert.False (region.IsInfinite (s_graphic));
|
|
Assert.Equal ([new (-5, -5, 10, 10)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Intersect_TestData))]
|
|
public void Intersect_GraphicsPath_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
using GraphicsPath path = new ();
|
|
path.AddRectangle (rect);
|
|
region.Intersect (path);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_EmptyPathWithInfiniteRegion_MakesEmpty ()
|
|
{
|
|
using Region region = new ();
|
|
using GraphicsPath graphicsPath = new ();
|
|
region.Intersect (graphicsPath);
|
|
Assert.True (region.IsEmpty (s_graphic));
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_NullGraphicsPath_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("path", () => region.Intersect ((GraphicsPath)null));
|
|
}
|
|
|
|
[Fact]
|
|
public void Intersect_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Region disposedRegion = CreateDisposedRegion ();
|
|
|
|
using GraphicsPath graphicsPath = new ();
|
|
using Region other = new ();
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Intersect (graphicsPath));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Intersect (new Rectangle ()));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Intersect (new RectangleF ()));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Intersect (other));
|
|
}
|
|
|
|
[Fact]
|
|
public void IsEmpty_NullGraphics_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("g", () => region.IsEmpty (null));
|
|
}
|
|
|
|
[Fact]
|
|
public void IsEmpty_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Assert.Throws<ArgumentException> (null, () => CreateDisposedRegion ().IsEmpty (s_graphic));
|
|
}
|
|
|
|
[Fact]
|
|
public void IsInfinite_NullGraphics_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("g", () => region.IsInfinite (null));
|
|
}
|
|
|
|
[Fact]
|
|
public void IsInfinite_DisposedGraphics_ThrowsArgumentException ()
|
|
{
|
|
using Region region = new ();
|
|
using Bitmap image = new (10, 10);
|
|
var graphics = Graphics.FromImage (image);
|
|
graphics.Dispose ();
|
|
Assert.Throws<ArgumentException> (null, () => region.IsInfinite (graphics));
|
|
}
|
|
|
|
[Fact]
|
|
public void IsInfinite_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Assert.Throws<ArgumentException> (null, () => CreateDisposedRegion ().IsInfinite (s_graphic));
|
|
}
|
|
|
|
public static IEnumerable<object []> IsVisible_Rectangle_TestData ()
|
|
{
|
|
Region infiniteExclude = new ();
|
|
infiniteExclude.Exclude (new Rectangle (387, 292, 189, 133));
|
|
infiniteExclude.Exclude (new Rectangle (387, 66, 189, 133));
|
|
|
|
yield return new object [] { infiniteExclude, new Rectangle (66, 292, 189, 133), true };
|
|
yield return new object [] { new Region (), Rectangle.Empty, false };
|
|
|
|
yield return new object [] { new Region (new Rectangle (0, 0, 10, 10)), new Rectangle (0, 0, 0, 1), false };
|
|
yield return new object [] { new Region (new Rectangle (500, 30, 60, 80)), new Rectangle (500, 30, 60, 80), true };
|
|
yield return new object [] { new Region (new Rectangle (500, 30, 60, 80)), new Rectangle (520, 40, 60, 80), true };
|
|
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Rectangle (1, 1, 2, 1), true };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Rectangle (1, 1, 2, 2), true };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Rectangle (1, 1, 10, 10), true };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Rectangle (1, 1, 1, 1), true };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Rectangle (2, 2, 1, 1), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Rectangle (0, 0, 1, 1), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Rectangle (3, 3, 1, 1), false };
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (IsVisible_Rectangle_TestData))]
|
|
public void IsVisible_Rectangle_ReturnsExpected (Region region, Rectangle rectangle, bool expected)
|
|
{
|
|
using (region)
|
|
using (Bitmap image = new (10, 10))
|
|
{
|
|
var disposedGraphics = Graphics.FromImage (image);
|
|
disposedGraphics.Dispose ();
|
|
|
|
Assert.Equal (expected, region.IsVisible (rectangle));
|
|
Assert.Equal (expected, region.IsVisible ((RectangleF)rectangle));
|
|
Assert.Equal (expected, region.IsVisible (rectangle, s_graphic));
|
|
Assert.Equal (expected, region.IsVisible (rectangle, disposedGraphics));
|
|
Assert.Equal (expected, region.IsVisible (rectangle, null));
|
|
Assert.Equal (expected, region.IsVisible ((RectangleF)rectangle, s_graphic));
|
|
Assert.Equal (expected, region.IsVisible ((RectangleF)rectangle, disposedGraphics));
|
|
Assert.Equal (expected, region.IsVisible ((RectangleF)rectangle, null));
|
|
|
|
Assert.Equal (expected, region.IsVisible (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height));
|
|
Assert.Equal (expected, region.IsVisible ((float)rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height));
|
|
Assert.Equal (expected, region.IsVisible (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, s_graphic));
|
|
Assert.Equal (expected, region.IsVisible (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, disposedGraphics));
|
|
Assert.Equal (expected, region.IsVisible (rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, null));
|
|
Assert.Equal (expected, region.IsVisible ((float)rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, s_graphic));
|
|
Assert.Equal (expected, region.IsVisible ((float)rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, disposedGraphics));
|
|
Assert.Equal (expected, region.IsVisible ((float)rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, null));
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<object []> IsVisible_Point_TestData ()
|
|
{
|
|
Region infiniteExclude = new ();
|
|
infiniteExclude.Exclude (new Rectangle (387, 292, 189, 133));
|
|
infiniteExclude.Exclude (new Rectangle (387, 66, 189, 133));
|
|
|
|
yield return new object [] { infiniteExclude, new Point (66, 292), true };
|
|
yield return new object [] { new Region (), Point.Empty, true };
|
|
|
|
yield return new object [] { new Region (new Rectangle (500, 30, 60, 80)), new Point (500, 29), false };
|
|
yield return new object [] { new Region (new Rectangle (500, 30, 60, 80)), new Point (500, 30), true };
|
|
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Point (0, 1), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Point (1, 0), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Point (2, 0), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Point (3, 0), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Point (1, 1), true };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Point (2, 1), true };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Point (3, 1), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Point (0, 2), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Point (2, 2), false };
|
|
yield return new object [] { new Region (new Rectangle (1, 1, 2, 1)), new Point (3, 2), false };
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (IsVisible_Point_TestData))]
|
|
public void IsVisible_Point_ReturnsExpected (Region region, Point point, bool expected)
|
|
{
|
|
using (region)
|
|
using (Bitmap image = new (10, 10))
|
|
{
|
|
var disposedGraphics = Graphics.FromImage (image);
|
|
disposedGraphics.Dispose ();
|
|
|
|
Assert.Equal (expected, region.IsVisible (point));
|
|
Assert.Equal (expected, region.IsVisible ((PointF)point));
|
|
Assert.Equal (expected, region.IsVisible (point, s_graphic));
|
|
Assert.Equal (expected, region.IsVisible (point, disposedGraphics));
|
|
Assert.Equal (expected, region.IsVisible (point, null));
|
|
Assert.Equal (expected, region.IsVisible ((PointF)point, s_graphic));
|
|
Assert.Equal (expected, region.IsVisible ((PointF)point, disposedGraphics));
|
|
Assert.Equal (expected, region.IsVisible ((PointF)point, null));
|
|
|
|
Assert.Equal (expected, region.IsVisible (point.X, point.Y));
|
|
Assert.Equal (expected, region.IsVisible (point.X, point.Y, s_graphic));
|
|
Assert.Equal (expected, region.IsVisible (point.X, point.Y, disposedGraphics));
|
|
Assert.Equal (expected, region.IsVisible (point.X, point.Y, null));
|
|
|
|
Assert.Equal (expected, region.IsVisible (point.X, point.Y, s_graphic));
|
|
Assert.Equal (expected, region.IsVisible (point.X, point.Y, disposedGraphics));
|
|
Assert.Equal (expected, region.IsVisible (point.X, point.Y, null));
|
|
Assert.Equal (expected, region.IsVisible ((float)point.X, point.Y, s_graphic));
|
|
Assert.Equal (expected, region.IsVisible ((float)point.X, point.Y, disposedGraphics));
|
|
Assert.Equal (expected, region.IsVisible ((float)point.X, point.Y, null));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void IsVisible_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Region disposedRegion = CreateDisposedRegion ();
|
|
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (1f, 2f));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (new PointF (1, 2)));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (new Point (1, 2)));
|
|
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (1f, 2f, s_graphic));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (new PointF (1, 2), s_graphic));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (new Point (1, 2), s_graphic));
|
|
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (1f, 2f, 3f, 4f));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (new Rectangle (1, 2, 3, 4)));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (new RectangleF (1, 2, 3, 4)));
|
|
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (1f, 2f, 3f, 4f, s_graphic));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (new Rectangle (1, 2, 3, 4), s_graphic));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (new RectangleF (1, 2, 3, 4), s_graphic));
|
|
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (1, 2, s_graphic));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (1, 2, 3, 4));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.IsVisible (1, 2, 3, 4, s_graphic));
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Region_TestData))]
|
|
public void MakeEmpty_NonEmpty_Success (Region region)
|
|
{
|
|
using (region)
|
|
{
|
|
region.MakeEmpty ();
|
|
Assert.True (region.IsEmpty (s_graphic));
|
|
Assert.False (region.IsInfinite (s_graphic));
|
|
Assert.Equal (RectangleF.Empty, region.GetBounds (s_graphic));
|
|
|
|
using (Matrix matrix = new ())
|
|
{
|
|
Assert.Empty (region.GetRegionScans (matrix));
|
|
}
|
|
|
|
region.MakeEmpty ();
|
|
Assert.True (region.IsEmpty (s_graphic));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void MakeEmpty_Disposed_ThrowsArgumentException () { Assert.Throws<ArgumentException> (null, () => CreateDisposedRegion ().MakeEmpty ()); }
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Region_TestData))]
|
|
public void MakeInfinite_NonInfinity_Success (Region region)
|
|
{
|
|
using (region)
|
|
{
|
|
region.MakeInfinite ();
|
|
Assert.False (region.IsEmpty (s_graphic));
|
|
Assert.True (region.IsInfinite (s_graphic));
|
|
Assert.Equal (new RectangleF (-4194304, -4194304, 8388608, 8388608), region.GetBounds (s_graphic));
|
|
|
|
region.MakeInfinite ();
|
|
Assert.False (region.IsEmpty (s_graphic));
|
|
Assert.True (region.IsInfinite (s_graphic));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void MakeInfinite_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Assert.Throws<ArgumentException> (null, () => CreateDisposedRegion ().MakeInfinite ());
|
|
}
|
|
|
|
public static IEnumerable<object []> Union_TestData ()
|
|
{
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (500, 30, 60, 80)),
|
|
new RectangleF [] { new (500, 30, 60, 80) },
|
|
new RectangleF [] { new (500, 30, 60, 80) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (500, 30, 60, 80)),
|
|
new RectangleF [] { RectangleF.Empty },
|
|
new RectangleF [] { new (500, 30, 60, 80) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (500, 30, 60, 80)),
|
|
new RectangleF [] { new (520, 30, 60, 80) },
|
|
new RectangleF [] { new (500, 30, 80, 80) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (500, 30, 60, 80)),
|
|
new RectangleF [] { new (520, 40, 60, 80) },
|
|
new RectangleF []
|
|
{
|
|
new (500, 30, 60, 10),
|
|
new (500, 40, 80, 70),
|
|
new (520, 110, 60, 10),
|
|
}
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (),
|
|
new RectangleF [] { new (520, 40, 60, 80) },
|
|
new RectangleF [] { new Rectangle (-4194304, -4194304, 8388608, 8388608) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (),
|
|
new RectangleF [] { RectangleF.Empty },
|
|
new RectangleF [] { new Rectangle (-4194304, -4194304, 8388608, 8388608) }
|
|
};
|
|
|
|
// No intersecting rects.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (20, 20, 20, 20)),
|
|
new RectangleF []
|
|
{
|
|
new (20, 80, 20, 10),
|
|
new (60, 60, 30, 10)
|
|
},
|
|
new RectangleF []
|
|
{
|
|
new (20, 20, 20, 20),
|
|
new (60, 60, 30, 10),
|
|
new (20, 80, 20, 10)
|
|
}
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (20, 180, 40, 50)),
|
|
new RectangleF []
|
|
{
|
|
new (50, 190, 40, 50),
|
|
new (70, 210, 30, 50)
|
|
},
|
|
new RectangleF []
|
|
{
|
|
new (20, 180, 40, 10),
|
|
new (20, 190, 70, 20),
|
|
new (20, 210, 80, 20),
|
|
new (50, 230, 50, 10),
|
|
new (70, 240, 30, 20)
|
|
}
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (20, 330, 40, 50)),
|
|
new RectangleF []
|
|
{
|
|
new (50, 340, 40, 50),
|
|
new (70, 360, 30, 50),
|
|
new (80, 400, 30, 10)
|
|
},
|
|
new RectangleF []
|
|
{
|
|
new (20, 330, 40, 10),
|
|
new (20, 340, 70, 20),
|
|
new (20, 360, 80, 20),
|
|
new (50, 380, 50, 10),
|
|
new (70, 390, 30, 10),
|
|
new (70, 400, 40, 10)
|
|
}
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (10, 20, 50, 50)),
|
|
new RectangleF []
|
|
{
|
|
new (100, 100, 60, 60),
|
|
new (200, 200, 80, 80)
|
|
},
|
|
new RectangleF []
|
|
{
|
|
new (10, 20, 50, 50),
|
|
new (100, 100, 60, 60),
|
|
new (200, 200, 80, 80)
|
|
}
|
|
};
|
|
|
|
// Intersecting from the right.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (10, 10, 100, 100)),
|
|
new RectangleF [] { new (40, 60, 100, 20) },
|
|
new RectangleF []
|
|
{
|
|
new (10, 10, 100, 50),
|
|
new (10, 60, 130, 20),
|
|
new (10, 80, 100, 30)
|
|
}
|
|
};
|
|
|
|
// Intersecting from the left.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (70, 10, 100, 100)),
|
|
new RectangleF [] { new (40, 60, 100, 20) },
|
|
new RectangleF []
|
|
{
|
|
new (70, 10, 100, 50),
|
|
new (40, 60, 130, 20),
|
|
new (70, 80, 100, 30)
|
|
}
|
|
};
|
|
|
|
// Intersecting from the top.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (40, 100, 100, 100)),
|
|
new RectangleF [] { new (70, 80, 50, 40) },
|
|
new RectangleF []
|
|
{
|
|
new (70, 80, 50, 20),
|
|
new (40, 100, 100, 100)
|
|
}
|
|
};
|
|
|
|
// Intersecting from the bottom.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (40, 10, 100, 100)),
|
|
new RectangleF [] { new (70, 80, 50, 40) },
|
|
new RectangleF []
|
|
{
|
|
new (40, 10, 100, 100),
|
|
new (70, 110, 50, 10)
|
|
}
|
|
};
|
|
|
|
// Multiple regions separated by 0 pixels.
|
|
yield return new object []
|
|
{
|
|
new Region (new Rectangle (30, 30, 80, 80)),
|
|
new RectangleF []
|
|
{
|
|
new (45, 45, 200, 200),
|
|
new (160, 260, 10, 10),
|
|
new (170, 260, 10, 10)
|
|
},
|
|
new RectangleF []
|
|
{
|
|
new (30, 30, 80, 15),
|
|
new (30, 45, 215, 65),
|
|
new (45, 110, 200, 135),
|
|
new (160, 260, 20, 10)
|
|
}
|
|
};
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Union_TestData))]
|
|
public void Union_Region_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
using Region other = new (rect);
|
|
region.Union (other);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Union_InfiniteRegion_Success ()
|
|
{
|
|
using Region region = new (new Rectangle (1, 2, 3, 4));
|
|
using Region other = new ();
|
|
using Matrix matrix = new ();
|
|
region.Union (other);
|
|
|
|
Assert.Equal ([new Rectangle (-4194304, -4194304, 8388608, 8388608)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Union_NullRegion_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("region", () => region.Union ((Region)null));
|
|
}
|
|
|
|
[Fact]
|
|
public void Union_DisposedRegion_ThrowsArgumentException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentException> (null, () => region.Union (CreateDisposedRegion ()));
|
|
}
|
|
|
|
[Fact]
|
|
public void Union_SameRegion_ThrowsInvalidOperationException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<InvalidOperationException> (() => region.Union (region));
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Union_TestData))]
|
|
public void Union_Rectangle_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
region.Union (new Rectangle ((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height));
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Union_TestData))]
|
|
public void Union_RectangleF_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
region.Union (rect);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Union_TestData))]
|
|
public void Union_GraphicsPath_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
using GraphicsPath path = new ();
|
|
path.AddRectangle (rect);
|
|
region.Union (path);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Union_EmptyPathWithInfiniteRegion_MakesInfinite ()
|
|
{
|
|
using Region region = new ();
|
|
using GraphicsPath graphicsPath = new ();
|
|
region.Union (graphicsPath);
|
|
Assert.True (region.IsInfinite (s_graphic));
|
|
}
|
|
|
|
[Fact]
|
|
public void Union_NullGraphicsPath_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("path", () => region.Union ((GraphicsPath)null));
|
|
}
|
|
|
|
[Fact]
|
|
public void Union_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Region disposedRegion = CreateDisposedRegion ();
|
|
|
|
using GraphicsPath graphicsPath = new ();
|
|
using Region other = new ();
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Union (graphicsPath));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Union (new Rectangle ()));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Union (new RectangleF ()));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Union (disposedRegion));
|
|
}
|
|
|
|
[Fact]
|
|
public void Transform_EmptyMatrix_Nop ()
|
|
{
|
|
using Region region = new (new RectangleF (1, 2, 3, 4));
|
|
using Matrix matrix = new ();
|
|
region.Transform (matrix);
|
|
Assert.Equal ([new (1, 2, 3, 4)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Transform_CustomMatrix_Success ()
|
|
{
|
|
using Region region = new (new RectangleF (1, 2, 3, 4));
|
|
using Matrix matrix = new ();
|
|
using Matrix emptyMatrix = new ();
|
|
matrix.Translate (10, 11);
|
|
matrix.Scale (5, 6);
|
|
|
|
region.Transform (matrix);
|
|
Assert.Equal ([new (15, 23, 15, 24)], region.GetRegionScans (emptyMatrix));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData (0, 0, 0)]
|
|
[InlineData (2, 2, 0)]
|
|
[InlineData (0.5, 0.5, 0)]
|
|
[InlineData (1, 1, 45)]
|
|
public void Transform_Infinity_Nop (float scaleX, float scaleY, int angle)
|
|
{
|
|
using Region region = new ();
|
|
using Matrix matrix = new ();
|
|
using Matrix emptyMatrix = new ();
|
|
matrix.Translate (10, 11);
|
|
matrix.Scale (scaleX, scaleY);
|
|
matrix.Rotate (angle);
|
|
|
|
region.Transform (matrix);
|
|
Assert.True (region.IsInfinite (s_graphic));
|
|
Assert.Equal ([new (-4194304, -4194304, 8388608, 8388608)], region.GetRegionScans (emptyMatrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Transform_InfinityIntersectScale_Success ()
|
|
{
|
|
using Region region = new ();
|
|
using Matrix matrix = new ();
|
|
using Matrix emptyMatrix = new ();
|
|
matrix.Scale (2, 0.5f);
|
|
|
|
region.Intersect (new Rectangle (-10, -10, 20, 20));
|
|
region.Transform (matrix);
|
|
Assert.False (region.IsInfinite (s_graphic));
|
|
Assert.Equal ([new (-20, -5, 40, 10)], region.GetRegionScans (emptyMatrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Transform_InfinityIntersectTransform_Success ()
|
|
{
|
|
using Region region = new ();
|
|
using Matrix matrix = new (2, 0, 0, 0.5f, 10, 10);
|
|
using Matrix emptyMatrix = new ();
|
|
region.Intersect (new Rectangle (-10, -10, 20, 20));
|
|
region.Transform (matrix);
|
|
|
|
Assert.False (region.IsInfinite (s_graphic));
|
|
Assert.Equal ([new (-10, 5, 40, 10)], region.GetRegionScans (emptyMatrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Transform_NullMatrix_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("matrix", () => region.Transform (null));
|
|
}
|
|
|
|
[Fact]
|
|
public void Transform_Disposed_ThrowsArgumentException ()
|
|
{
|
|
using Matrix matrix = new ();
|
|
Assert.Throws<ArgumentException> (null, () => CreateDisposedRegion ().Transform (matrix));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData (0, 0)]
|
|
[InlineData (2, 3)]
|
|
[InlineData (-2, -3)]
|
|
public void Translate_Int_Success (float dx, float dy)
|
|
{
|
|
using Region region = new (new RectangleF (1, 2, 3, 4));
|
|
using Matrix matrix = new ();
|
|
region.Translate (dx, dy);
|
|
Assert.Equal ([new (1 + dx, 2 + dy, 3, 4)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Translate_IntInfinityIntersect_Success ()
|
|
{
|
|
using Region region = new ();
|
|
using Matrix matrix = new ();
|
|
region.Intersect (new Rectangle (-10, -10, 20, 20));
|
|
region.Translate (10, 10);
|
|
|
|
Assert.False (region.IsInfinite (s_graphic));
|
|
Assert.Equal ([new (0, 0, 20, 20)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData (0, 0)]
|
|
[InlineData (2, 3)]
|
|
public void Translate_Float_Success (int dx, int dy)
|
|
{
|
|
using Region region = new (new RectangleF (1, 2, 3, 4));
|
|
using Matrix matrix = new ();
|
|
region.Translate (dx, dy);
|
|
Assert.Equal ([new (1 + dx, 2 + dy, 3, 4)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Translate_FloatInfinityIntersect_Success ()
|
|
{
|
|
using Region region = new ();
|
|
using Matrix matrix = new ();
|
|
region.Intersect (new Rectangle (-10, -10, 20, 20));
|
|
region.Translate (10f, 10f);
|
|
|
|
Assert.False (region.IsInfinite (s_graphic));
|
|
Assert.Equal ([new (0, 0, 20, 20)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Translate_Infinity_Nop ()
|
|
{
|
|
using Region region = new ();
|
|
using Matrix matrix = new ();
|
|
region.Translate (10, 10);
|
|
region.Translate (10f, 10f);
|
|
|
|
Assert.True (region.IsInfinite (s_graphic));
|
|
Assert.Equal ([new (-4194304, -4194304, 8388608, 8388608)], region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData (float.MaxValue)]
|
|
[InlineData (float.MinValue)]
|
|
[InlineData (float.NaN)]
|
|
[InlineData (float.PositiveInfinity)]
|
|
[InlineData (float.NegativeInfinity)]
|
|
public void Translate_InvalidFloatValue_EmptiesRegion (float f)
|
|
{
|
|
using Region region = new (new RectangleF (1, 2, 3, 4));
|
|
using Matrix matrix = new ();
|
|
region.Translate (f, 0);
|
|
|
|
Assert.True (region.IsEmpty (s_graphic));
|
|
Assert.False (region.IsInfinite (s_graphic));
|
|
Assert.Empty (region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Translate_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Region disposedRegion = CreateDisposedRegion ();
|
|
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Translate (1, 2));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Translate (1f, 2f));
|
|
}
|
|
|
|
public static IEnumerable<object []> Xor_TestData ()
|
|
{
|
|
yield return new object []
|
|
{
|
|
new Region (new RectangleF (500, 30, 60, 80)),
|
|
new RectangleF [] { new (500, 30, 60, 80) },
|
|
new RectangleF[0]
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new RectangleF (500, 30, 60, 80)),
|
|
new RectangleF [] { RectangleF.Empty },
|
|
new RectangleF [] { new (500, 30, 60, 80) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new RectangleF (0, 0, 0, 0)),
|
|
new RectangleF [] { new (500, 30, 60, 80) },
|
|
new RectangleF [] { new (500, 30, 60, 80) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (),
|
|
new RectangleF [] { new (520, 40, 60, 80) },
|
|
new RectangleF []
|
|
{
|
|
new (-4194304, -4194304, 8388608, 4194344),
|
|
new (-4194304, 40, 4194824, 80),
|
|
new (580, 40, 4193724, 80),
|
|
new (-4194304, 120, 8388608, 4194184)
|
|
}
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (),
|
|
new RectangleF [] { RectangleF.Empty },
|
|
new RectangleF [] { new Rectangle (-4194304, -4194304, 8388608, 8388608) }
|
|
};
|
|
|
|
yield return new object []
|
|
{
|
|
new Region (new RectangleF (380, 30, 60, 80)),
|
|
new RectangleF [] { new (410, 40, 60, 80) },
|
|
new RectangleF []
|
|
{
|
|
new (380, 30, 60, 10),
|
|
new (380, 40, 30, 70),
|
|
new (440, 40, 30, 70),
|
|
new (410, 110, 60, 10)
|
|
}
|
|
};
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Xor_TestData))]
|
|
public void Xor_Region_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
using Region other = new (rect);
|
|
region.Xor (other);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Xor_InfiniteRegion_Success ()
|
|
{
|
|
using Region region = new (new Rectangle (1, 2, 3, 4));
|
|
using Region other = new ();
|
|
using Matrix matrix = new ();
|
|
region.Xor (other);
|
|
|
|
Assert.Equal (
|
|
[
|
|
new (-4194304, -4194304, 8388608, 4194306),
|
|
new (-4194304, 2, 4194305, 4),
|
|
new (4, 2, 4194300, 4),
|
|
new (-4194304, 6, 8388608, 4194298)
|
|
],
|
|
region.GetRegionScans (matrix));
|
|
}
|
|
|
|
[Fact]
|
|
public void Xor_NullRegion_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("region", () => region.Xor ((Region)null));
|
|
}
|
|
|
|
[Fact]
|
|
public void Xor_DisposedRegion_ThrowsArgumentException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentException> (null, () => region.Xor (CreateDisposedRegion ()));
|
|
}
|
|
|
|
[Fact]
|
|
public void Xor_SameRegion_ThrowsInvalidOperationException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<InvalidOperationException> (() => region.Xor (region));
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Xor_TestData))]
|
|
public void Xor_Rectangle_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
region.Xor (new Rectangle ((int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height));
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Xor_TestData))]
|
|
public void Xor_RectangleF_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
region.Xor (rect);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData (nameof (Xor_TestData))]
|
|
public void Xor_GraphicsPath_Success (Region region, RectangleF [] rectangles, RectangleF [] expectedScans)
|
|
{
|
|
using (region)
|
|
{
|
|
foreach (RectangleF rect in rectangles)
|
|
{
|
|
using GraphicsPath path = new ();
|
|
path.AddRectangle (rect);
|
|
region.Xor (path);
|
|
}
|
|
|
|
using Matrix matrix = new ();
|
|
Assert.Equal (expectedScans, region.GetRegionScans (matrix));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Xor_EmptyPathWithInfiniteRegion_MakesInfinite ()
|
|
{
|
|
using Region region = new ();
|
|
using GraphicsPath graphicsPath = new ();
|
|
region.Xor (graphicsPath);
|
|
Assert.True (region.IsInfinite (s_graphic));
|
|
}
|
|
|
|
[Fact]
|
|
public void Xor_NullGraphicsPath_ThrowsArgumentNullException ()
|
|
{
|
|
using Region region = new ();
|
|
Assert.Throws<ArgumentNullException> ("path", () => region.Xor ((GraphicsPath)null));
|
|
}
|
|
|
|
[Fact]
|
|
public void Xor_Disposed_ThrowsArgumentException ()
|
|
{
|
|
Region disposedRegion = CreateDisposedRegion ();
|
|
|
|
using GraphicsPath graphicsPath = new ();
|
|
using Region other = new ();
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Xor (graphicsPath));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Xor (new Rectangle ()));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Xor (new RectangleF ()));
|
|
Assert.Throws<ArgumentException> (null, () => disposedRegion.Xor (other));
|
|
}
|
|
|
|
}
|
|
#endif |