mirror of https://github.com/oliverbooth/X10D
test: use NUnit constraint API in X10D.Unity.Tests (#76)
This commit is contained in:
parent
744f5e906b
commit
fcdcf54aa3
|
|
@ -20,8 +20,8 @@ namespace X10D.Unity.Tests
|
|||
child.AddComponent<Rigidbody>();
|
||||
|
||||
Rigidbody[] components = rigidbody.GetComponentsInChildrenOnly<Rigidbody>();
|
||||
Assert.AreEqual(1, components.Length);
|
||||
Assert.AreEqual(components[0].gameObject, child);
|
||||
Assert.That(components.Length, Is.EqualTo(1));
|
||||
Assert.That(child, Is.EqualTo(components[0].gameObject));
|
||||
|
||||
yield break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,15 +22,15 @@ namespace X10D.Unity.Tests.Drawing
|
|||
byte a, r, g, b;
|
||||
|
||||
(r, g, b) = White;
|
||||
Assert.AreEqual(255, r);
|
||||
Assert.AreEqual(255, g);
|
||||
Assert.AreEqual(255, b);
|
||||
Assert.That(r, Is.EqualTo(255));
|
||||
Assert.That(g, Is.EqualTo(255));
|
||||
Assert.That(b, Is.EqualTo(255));
|
||||
|
||||
(a, r, g, b) = Yellow;
|
||||
Assert.AreEqual(255, a);
|
||||
Assert.AreEqual(255, r);
|
||||
Assert.AreEqual(255, g);
|
||||
Assert.AreEqual(0, b);
|
||||
Assert.That(a, Is.EqualTo(255));
|
||||
Assert.That(r, Is.EqualTo(255));
|
||||
Assert.That(g, Is.EqualTo(255));
|
||||
Assert.That(b, Is.EqualTo(0));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -38,30 +38,30 @@ namespace X10D.Unity.Tests.Drawing
|
|||
{
|
||||
// I know it's just casting... but aim for 100% coverage babyyyy
|
||||
|
||||
Assert.AreEqual(ConsoleColor.Red, ((Color32)Color.red).GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Green, ((Color32)Color.green).GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Blue, ((Color32)Color.blue).GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.White, ((Color32)Color.white).GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Black, ((Color32)Color.black).GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Yellow, ((Color32)Color.yellow).GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Cyan, ((Color32)Color.cyan).GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Magenta, ((Color32)Color.magenta).GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Gray, ((Color32)Color.gray).GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Gray, ((Color32)Color.grey).GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Black, ((Color32)Color.clear).GetClosestConsoleColor());
|
||||
Assert.That(((Color32)Color.red).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Red));
|
||||
Assert.That(((Color32)Color.green).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Green));
|
||||
Assert.That(((Color32)Color.blue).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Blue));
|
||||
Assert.That(((Color32)Color.white).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.White));
|
||||
Assert.That(((Color32)Color.black).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Black));
|
||||
Assert.That(((Color32)Color.yellow).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Yellow));
|
||||
Assert.That(((Color32)Color.cyan).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Cyan));
|
||||
Assert.That(((Color32)Color.magenta).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Magenta));
|
||||
Assert.That(((Color32)Color.gray).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Gray));
|
||||
Assert.That(((Color32)Color.grey).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Gray));
|
||||
Assert.That(((Color32)Color.clear).GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Black));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Inverted_ShouldReturnInvertedColor()
|
||||
{
|
||||
Assert.AreEqual(White, Black.Inverted());
|
||||
Assert.AreEqual(Black, White.Inverted());
|
||||
Assert.AreEqual(Red, Cyan.Inverted());
|
||||
Assert.AreEqual(Cyan, Red.Inverted());
|
||||
Assert.AreEqual(Green, Magenta.Inverted());
|
||||
Assert.AreEqual(Magenta, Green.Inverted());
|
||||
Assert.AreEqual(Yellow, Blue.Inverted());
|
||||
Assert.AreEqual(Blue, Yellow.Inverted());
|
||||
Assert.That(Black.Inverted(), Is.EqualTo(White));
|
||||
Assert.That(White.Inverted(), Is.EqualTo(Black));
|
||||
Assert.That(Cyan.Inverted(), Is.EqualTo(Red));
|
||||
Assert.That(Red.Inverted(), Is.EqualTo(Cyan));
|
||||
Assert.That(Magenta.Inverted(), Is.EqualTo(Green));
|
||||
Assert.That(Green.Inverted(), Is.EqualTo(Magenta));
|
||||
Assert.That(Blue.Inverted(), Is.EqualTo(Yellow));
|
||||
Assert.That(Yellow.Inverted(), Is.EqualTo(Blue));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -70,7 +70,7 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var expected = new Color32(0, 0, 0, 255);
|
||||
var actual = new Color32(255, 255, 255, 255).Inverted();
|
||||
|
||||
Assert.AreEqual(expected, actual);
|
||||
Assert.That(actual, Is.EqualTo(expected));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -79,7 +79,7 @@ namespace X10D.Unity.Tests.Drawing
|
|||
System.Drawing.Color expected = System.Drawing.Color.FromArgb(255, 255, 255);
|
||||
System.Drawing.Color actual = White.ToSystemDrawingColor();
|
||||
|
||||
Assert.AreEqual(expected, actual);
|
||||
Assert.That(actual, Is.EqualTo(expected));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -88,36 +88,36 @@ namespace X10D.Unity.Tests.Drawing
|
|||
Color32 expected = White;
|
||||
Color32 actual = System.Drawing.Color.FromArgb(255, 255, 255).ToUnityColor32();
|
||||
|
||||
Assert.AreEqual(expected, actual);
|
||||
Assert.That(actual, Is.EqualTo(expected));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithA0_ShouldReturnSameColor_GivenWhite()
|
||||
{
|
||||
var transparent = new Color32(255, 255, 255, 0);
|
||||
Assert.AreEqual(transparent, White.WithA(0));
|
||||
Assert.AreEqual(transparent, transparent.WithA(0));
|
||||
Assert.That(White.WithA(0), Is.EqualTo(transparent));
|
||||
Assert.That(transparent.WithA(0), Is.EqualTo(transparent));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithB0_ShouldReturnYellow_GivenWhite()
|
||||
{
|
||||
Assert.AreEqual(Yellow, White.WithB(0));
|
||||
Assert.AreEqual(Yellow, Yellow.WithB(0));
|
||||
Assert.That(White.WithB(0), Is.EqualTo(Yellow));
|
||||
Assert.That(Yellow.WithB(0), Is.EqualTo(Yellow));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithG0_ShouldReturnMagenta_GivenWhite()
|
||||
{
|
||||
Assert.AreEqual(Magenta, White.WithG(0));
|
||||
Assert.AreEqual(Magenta, Magenta.WithG(0));
|
||||
Assert.That(White.WithG(0), Is.EqualTo(Magenta));
|
||||
Assert.That(Magenta.WithG(0), Is.EqualTo(Magenta));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithR0_ShouldReturnCyan_GivenWhite()
|
||||
{
|
||||
Assert.AreEqual(Cyan, White.WithR(0));
|
||||
Assert.AreEqual(Cyan, Cyan.WithR(0));
|
||||
Assert.That(White.WithR(0), Is.EqualTo(Cyan));
|
||||
Assert.That(Cyan.WithR(0), Is.EqualTo(Cyan));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,44 +22,44 @@ namespace X10D.Unity.Tests.Drawing
|
|||
float a, r, g, b;
|
||||
|
||||
(r, g, b) = White;
|
||||
Assert.AreEqual(1.0f, r);
|
||||
Assert.AreEqual(1.0f, g);
|
||||
Assert.AreEqual(1.0f, b);
|
||||
Assert.That(r, Is.EqualTo(1.0f));
|
||||
Assert.That(g, Is.EqualTo(1.0f));
|
||||
Assert.That(b, Is.EqualTo(1.0f));
|
||||
|
||||
(a, r, g, b) = Yellow;
|
||||
Assert.AreEqual(1.0f, a);
|
||||
Assert.AreEqual(1.0f, r);
|
||||
Assert.AreEqual(1.0f, g);
|
||||
Assert.AreEqual(0.0f, b);
|
||||
Assert.That(a, Is.EqualTo(1.0f));
|
||||
Assert.That(r, Is.EqualTo(1.0f));
|
||||
Assert.That(g, Is.EqualTo(1.0f));
|
||||
Assert.That(b, Is.EqualTo(0.0f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetClosestConsoleColor_ShouldReturnClosestColor_GivenValidColor()
|
||||
{
|
||||
Assert.AreEqual(ConsoleColor.Red, Color.red.GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Green, Color.green.GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Blue, Color.blue.GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.White, Color.white.GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Black, Color.black.GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Yellow, Color.yellow.GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Cyan, Color.cyan.GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Magenta, Color.magenta.GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Gray, Color.gray.GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Gray, Color.grey.GetClosestConsoleColor());
|
||||
Assert.AreEqual(ConsoleColor.Black, Color.clear.GetClosestConsoleColor());
|
||||
Assert.That(Color.red.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Red));
|
||||
Assert.That(Color.green.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Green));
|
||||
Assert.That(Color.blue.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Blue));
|
||||
Assert.That(Color.white.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.White));
|
||||
Assert.That(Color.black.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Black));
|
||||
Assert.That(Color.yellow.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Yellow));
|
||||
Assert.That(Color.cyan.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Cyan));
|
||||
Assert.That(Color.magenta.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Magenta));
|
||||
Assert.That(Color.gray.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Gray));
|
||||
Assert.That(Color.grey.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Gray));
|
||||
Assert.That(Color.clear.GetClosestConsoleColor(), Is.EqualTo(ConsoleColor.Black));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Inverted_ShouldReturnInvertedColor()
|
||||
{
|
||||
Assert.AreEqual(White, Black.Inverted());
|
||||
Assert.AreEqual(Black, White.Inverted());
|
||||
Assert.AreEqual(Red, Cyan.Inverted());
|
||||
Assert.AreEqual(Cyan, Red.Inverted());
|
||||
Assert.AreEqual(Green, Magenta.Inverted());
|
||||
Assert.AreEqual(Magenta, Green.Inverted());
|
||||
Assert.AreEqual(Yellow, Blue.Inverted());
|
||||
Assert.AreEqual(Blue, Yellow.Inverted());
|
||||
Assert.That(Black.Inverted(), Is.EqualTo(White));
|
||||
Assert.That(White.Inverted(), Is.EqualTo(Black));
|
||||
Assert.That(Cyan.Inverted(), Is.EqualTo(Red));
|
||||
Assert.That(Red.Inverted(), Is.EqualTo(Cyan));
|
||||
Assert.That(Magenta.Inverted(), Is.EqualTo(Green));
|
||||
Assert.That(Green.Inverted(), Is.EqualTo(Magenta));
|
||||
Assert.That(Blue.Inverted(), Is.EqualTo(Yellow));
|
||||
Assert.That(Yellow.Inverted(), Is.EqualTo(Blue));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -68,7 +68,7 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var expected = new Color(0, 0, 0, 1);
|
||||
var actual = new Color(1, 1, 1, 1).Inverted();
|
||||
|
||||
Assert.AreEqual(expected, actual);
|
||||
Assert.That(actual, Is.EqualTo(expected));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -77,7 +77,7 @@ namespace X10D.Unity.Tests.Drawing
|
|||
System.Drawing.Color expected = System.Drawing.Color.FromArgb(255, 255, 255);
|
||||
System.Drawing.Color actual = White.ToSystemDrawingColor();
|
||||
|
||||
Assert.AreEqual(expected, actual);
|
||||
Assert.That(actual, Is.EqualTo(expected));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -86,36 +86,36 @@ namespace X10D.Unity.Tests.Drawing
|
|||
Color expected = White;
|
||||
Color actual = System.Drawing.Color.FromArgb(255, 255, 255).ToUnityColor();
|
||||
|
||||
Assert.AreEqual(expected, actual);
|
||||
Assert.That(actual, Is.EqualTo(expected));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithA0_ShouldReturnSameColor_GivenWhite()
|
||||
{
|
||||
var transparent = new Color(1, 1, 1, 0);
|
||||
Assert.AreEqual(transparent, White.WithA(0));
|
||||
Assert.AreEqual(transparent, transparent.WithA(0));
|
||||
Assert.That(White.WithA(0), Is.EqualTo(transparent));
|
||||
Assert.That(transparent.WithA(0), Is.EqualTo(transparent));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithB0_ShouldReturnYellow_GivenWhite()
|
||||
{
|
||||
Assert.AreEqual(Yellow, White.WithB(0));
|
||||
Assert.AreEqual(Yellow, Yellow.WithB(0));
|
||||
Assert.That(White.WithB(0), Is.EqualTo(Yellow));
|
||||
Assert.That(Yellow.WithB(0), Is.EqualTo(Yellow));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithG0_ShouldReturnMagenta_GivenWhite()
|
||||
{
|
||||
Assert.AreEqual(Magenta, White.WithG(0));
|
||||
Assert.AreEqual(Magenta, Magenta.WithG(0));
|
||||
Assert.That(White.WithG(0), Is.EqualTo(Magenta));
|
||||
Assert.That(Magenta.WithG(0), Is.EqualTo(Magenta));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithR0_ShouldReturnCyan_GivenWhite()
|
||||
{
|
||||
Assert.AreEqual(Cyan, White.WithR(0));
|
||||
Assert.AreEqual(Cyan, Cyan.WithR(0));
|
||||
Assert.That(White.WithR(0), Is.EqualTo(Cyan));
|
||||
Assert.That(Cyan.WithR(0), Is.EqualTo(Cyan));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,8 +15,8 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var point = new PointF(random.NextSingle(), random.NextSingle());
|
||||
var vector = point.ToUnityVector2();
|
||||
|
||||
Assert.AreEqual(point.X, vector.x, 1e-6f);
|
||||
Assert.AreEqual(point.Y, vector.y, 1e-6f);
|
||||
Assert.That(vector.x, Is.EqualTo(point.X).Within(1e-6f));
|
||||
Assert.That(vector.y, Is.EqualTo(point.Y).Within(1e-6f));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,8 +14,8 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var point = new Point(random.Next(), random.Next());
|
||||
var vector = point.ToUnityVector2();
|
||||
|
||||
Assert.AreEqual(point.X, vector.x);
|
||||
Assert.AreEqual(point.Y, vector.y);
|
||||
Assert.That(vector.x, Is.EqualTo(point.X));
|
||||
Assert.That(vector.y, Is.EqualTo(point.Y));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -25,8 +25,8 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var point = new Point(random.Next(), random.Next());
|
||||
var vector = point.ToUnityVector2Int();
|
||||
|
||||
Assert.AreEqual(point.X, vector.x);
|
||||
Assert.AreEqual(point.Y, vector.y);
|
||||
Assert.That(vector.x, Is.EqualTo(point.X));
|
||||
Assert.That(vector.y, Is.EqualTo(point.Y));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,10 +15,10 @@ namespace X10D.Unity.Tests.Drawing
|
|||
{
|
||||
var random = new Random(1234);
|
||||
var color = random.NextColorArgb();
|
||||
Assert.AreEqual(0.373868465f, color.r, 1e-6f);
|
||||
Assert.AreEqual(0.391597569f, color.g, 1e-6f);
|
||||
Assert.AreEqual(0.675019085f, color.b, 1e-6f);
|
||||
Assert.AreEqual(0.234300315f, color.a, 1e-6f);
|
||||
Assert.That(color.r, Is.EqualTo(0.373868465f).Within(1e-6f));
|
||||
Assert.That(color.g, Is.EqualTo(0.391597569f).Within(1e-6f));
|
||||
Assert.That(color.b, Is.EqualTo(0.675019085f).Within(1e-6f));
|
||||
Assert.That(color.a, Is.EqualTo(0.234300315f).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -32,7 +32,7 @@ namespace X10D.Unity.Tests.Drawing
|
|||
public void NextColor32Argb_ShouldReturn331515e5_GivenSeed1234()
|
||||
{
|
||||
var random = new Random(1234);
|
||||
Assert.AreEqual(new Color32(21, 21, 229, 51), random.NextColor32Argb());
|
||||
Assert.That(random.NextColor32Argb(), Is.EqualTo(new Color32(21, 21, 229, 51)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -47,10 +47,10 @@ namespace X10D.Unity.Tests.Drawing
|
|||
{
|
||||
var random = new Random(1234);
|
||||
var color = random.NextColorRgb();
|
||||
Assert.AreEqual(0.234300315f, color.r, 1e-6f);
|
||||
Assert.AreEqual(0.373868465f, color.g, 1e-6f);
|
||||
Assert.AreEqual(0.391597569f, color.b, 1e-6f);
|
||||
Assert.AreEqual(1, color.a, 1e-6f);
|
||||
Assert.That(color.r, Is.EqualTo(0.234300315f).Within(1e-6f));
|
||||
Assert.That(color.g, Is.EqualTo(0.373868465f).Within(1e-6f));
|
||||
Assert.That(color.b, Is.EqualTo(0.391597569f).Within(1e-6f));
|
||||
Assert.That(color.a, Is.EqualTo(1).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -64,7 +64,7 @@ namespace X10D.Unity.Tests.Drawing
|
|||
public void NextColor32Rgb_ShouldReturn1515e5_GivenSeed1234()
|
||||
{
|
||||
var random = new Random(1234);
|
||||
Assert.AreEqual(new Color32(21, 21, 229, 255), random.NextColor32Rgb());
|
||||
Assert.That(random.NextColor32Rgb(), Is.EqualTo(new Color32(21, 21, 229, 255)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
|
|||
|
|
@ -14,10 +14,10 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var rect = new RectInt(random.Next(), random.Next(), random.Next(), random.Next());
|
||||
var rectangle = rect.ToSystemRectangle();
|
||||
|
||||
Assert.AreEqual(rect.x, rectangle.X);
|
||||
Assert.AreEqual(rect.y, rectangle.Y);
|
||||
Assert.AreEqual(rect.width, rectangle.Width);
|
||||
Assert.AreEqual(rect.height, rectangle.Height);
|
||||
Assert.That(rectangle.X, Is.EqualTo(rect.x));
|
||||
Assert.That(rectangle.Y, Is.EqualTo(rect.y));
|
||||
Assert.That(rectangle.Width, Is.EqualTo(rect.width));
|
||||
Assert.That(rectangle.Height, Is.EqualTo(rect.height));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -27,10 +27,10 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var rect = new RectInt(random.Next(), random.Next(), random.Next(), random.Next());
|
||||
var rectangle = rect.ToSystemRectangleF();
|
||||
|
||||
Assert.AreEqual(rect.x, rectangle.X);
|
||||
Assert.AreEqual(rect.y, rectangle.Y);
|
||||
Assert.AreEqual(rect.width, rectangle.Width);
|
||||
Assert.AreEqual(rect.height, rectangle.Height);
|
||||
Assert.That(rectangle.X, Is.EqualTo(rect.x));
|
||||
Assert.That(rectangle.Y, Is.EqualTo(rect.y));
|
||||
Assert.That(rectangle.Width, Is.EqualTo(rect.width));
|
||||
Assert.That(rectangle.Height, Is.EqualTo(rect.height));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,10 +15,10 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var rect = new Rect(random.NextSingle(), random.NextSingle(), random.NextSingle(), random.NextSingle());
|
||||
var rectangle = rect.ToSystemRectangleF();
|
||||
|
||||
Assert.AreEqual(rect.x, rectangle.X, 1e-6f);
|
||||
Assert.AreEqual(rect.y, rectangle.Y, 1e-6f);
|
||||
Assert.AreEqual(rect.width, rectangle.Width, 1e-6f);
|
||||
Assert.AreEqual(rect.height, rectangle.Height, 1e-6f);
|
||||
Assert.That(rectangle.X, Is.EqualTo(rect.x).Within(1e-6f));
|
||||
Assert.That(rectangle.Y, Is.EqualTo(rect.y).Within(1e-6f));
|
||||
Assert.That(rectangle.Width, Is.EqualTo(rect.width).Within(1e-6f));
|
||||
Assert.That(rectangle.Height, Is.EqualTo(rect.height).Within(1e-6f));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,10 +15,10 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var rectangle = new RectangleF(random.NextSingle(), random.NextSingle(), random.NextSingle(), random.NextSingle());
|
||||
var rect = rectangle.ToUnityRect();
|
||||
|
||||
Assert.AreEqual(rectangle.X, rect.x, 1e-6f);
|
||||
Assert.AreEqual(rectangle.Y, rect.y, 1e-6f);
|
||||
Assert.AreEqual(rectangle.Width, rect.width, 1e-6f);
|
||||
Assert.AreEqual(rectangle.Height, rect.height, 1e-6f);
|
||||
Assert.That(rect.x, Is.EqualTo(rectangle.X).Within(1e-6f));
|
||||
Assert.That(rect.y, Is.EqualTo(rectangle.Y).Within(1e-6f));
|
||||
Assert.That(rect.width, Is.EqualTo(rectangle.Width).Within(1e-6f));
|
||||
Assert.That(rect.height, Is.EqualTo(rectangle.Height).Within(1e-6f));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,10 +14,10 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var rectangle = new Rectangle(random.Next(), random.Next(), random.Next(), random.Next());
|
||||
var rect = rectangle.ToUnityRect();
|
||||
|
||||
Assert.AreEqual(rectangle.X, rect.x);
|
||||
Assert.AreEqual(rectangle.Y, rect.y);
|
||||
Assert.AreEqual(rectangle.Width, rect.width);
|
||||
Assert.AreEqual(rectangle.Height, rect.height);
|
||||
Assert.That(rect.x, Is.EqualTo(rectangle.X));
|
||||
Assert.That(rect.y, Is.EqualTo(rectangle.Y));
|
||||
Assert.That(rect.width, Is.EqualTo(rectangle.Width));
|
||||
Assert.That(rect.height, Is.EqualTo(rectangle.Height));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -27,10 +27,10 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var rectangle = new Rectangle(random.Next(), random.Next(), random.Next(), random.Next());
|
||||
var rect = rectangle.ToUnityRectInt();
|
||||
|
||||
Assert.AreEqual(rectangle.X, rect.x);
|
||||
Assert.AreEqual(rectangle.Y, rect.y);
|
||||
Assert.AreEqual(rectangle.Width, rect.width);
|
||||
Assert.AreEqual(rectangle.Height, rect.height);
|
||||
Assert.That(rect.x, Is.EqualTo(rectangle.X));
|
||||
Assert.That(rect.y, Is.EqualTo(rectangle.Y));
|
||||
Assert.That(rect.width, Is.EqualTo(rectangle.Width));
|
||||
Assert.That(rect.height, Is.EqualTo(rectangle.Height));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,8 +15,8 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var size = new SizeF(random.NextSingle(), random.NextSingle());
|
||||
var vector = size.ToUnityVector2();
|
||||
|
||||
Assert.AreEqual(size.Width, vector.x, 1e-6f);
|
||||
Assert.AreEqual(size.Height, vector.y, 1e-6f);
|
||||
Assert.That(vector.x, Is.EqualTo(size.Width).Within(1e-6f));
|
||||
Assert.That(vector.y, Is.EqualTo(size.Height).Within(1e-6f));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,8 +14,8 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var size = new Size(random.Next(), random.Next());
|
||||
var vector = size.ToUnityVector2();
|
||||
|
||||
Assert.AreEqual(size.Width, vector.x);
|
||||
Assert.AreEqual(size.Height, vector.y);
|
||||
Assert.That(vector.x, Is.EqualTo(size.Width));
|
||||
Assert.That(vector.y, Is.EqualTo(size.Height));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -25,8 +25,8 @@ namespace X10D.Unity.Tests.Drawing
|
|||
var size = new Size(random.Next(), random.Next());
|
||||
var vector = size.ToUnityVector2Int();
|
||||
|
||||
Assert.AreEqual(size.Width, vector.x);
|
||||
Assert.AreEqual(size.Height, vector.y);
|
||||
Assert.That(vector.x, Is.EqualTo(size.Width));
|
||||
Assert.That(vector.y, Is.EqualTo(size.Height));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,8 +20,8 @@ namespace X10D.Unity.Tests
|
|||
child.AddComponent<Rigidbody>();
|
||||
|
||||
Rigidbody[] components = parent.GetComponentsInChildrenOnly<Rigidbody>();
|
||||
Assert.AreEqual(1, components.Length);
|
||||
Assert.AreEqual(components[0].gameObject, child);
|
||||
Assert.That(components.Length, Is.EqualTo(1));
|
||||
Assert.That(child, Is.EqualTo(components[0].gameObject));
|
||||
|
||||
yield break;
|
||||
}
|
||||
|
|
@ -34,29 +34,29 @@ namespace X10D.Unity.Tests
|
|||
Transform firstTransform = first.transform;
|
||||
Transform secondTransform = second.transform;
|
||||
|
||||
Assert.AreEqual(Quaternion.identity, firstTransform.rotation);
|
||||
Assert.AreEqual(Quaternion.identity, secondTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(Quaternion.identity));
|
||||
Assert.That(secondTransform.rotation, Is.EqualTo(Quaternion.identity));
|
||||
|
||||
firstTransform.LookAt(secondTransform);
|
||||
Quaternion expected = firstTransform.rotation;
|
||||
|
||||
firstTransform.rotation = Quaternion.identity;
|
||||
Assert.AreEqual(Quaternion.identity, firstTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(Quaternion.identity));
|
||||
|
||||
first.LookAt(second);
|
||||
Assert.AreEqual(expected, firstTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(expected));
|
||||
|
||||
firstTransform.rotation = Quaternion.identity;
|
||||
Assert.AreEqual(Quaternion.identity, firstTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(Quaternion.identity));
|
||||
|
||||
first.LookAt(second.transform);
|
||||
Assert.AreEqual(expected, firstTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(expected));
|
||||
|
||||
firstTransform.rotation = Quaternion.identity;
|
||||
Assert.AreEqual(Quaternion.identity, firstTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(Quaternion.identity));
|
||||
|
||||
first.LookAt(Vector3.right);
|
||||
Assert.AreEqual(expected, firstTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(expected));
|
||||
|
||||
yield break;
|
||||
}
|
||||
|
|
@ -78,9 +78,9 @@ namespace X10D.Unity.Tests
|
|||
|
||||
parent.SetLayerRecursively(layer);
|
||||
|
||||
Assert.AreEqual(layer, parent.layer);
|
||||
Assert.AreEqual(layer, child.layer);
|
||||
Assert.AreEqual(layer, grandChild.layer);
|
||||
Assert.That(parent.layer, Is.EqualTo(layer));
|
||||
Assert.That(child.layer, Is.EqualTo(layer));
|
||||
Assert.That(grandChild.layer, Is.EqualTo(layer));
|
||||
|
||||
yield break;
|
||||
}
|
||||
|
|
@ -91,17 +91,17 @@ namespace X10D.Unity.Tests
|
|||
var first = new GameObject {transform = {position = Vector3.zero, rotation = Quaternion.identity}};
|
||||
var second = new GameObject {transform = {position = Vector3.right, rotation = Quaternion.identity}};
|
||||
|
||||
Assert.AreEqual(null, first.transform.parent);
|
||||
Assert.AreEqual(null, second.transform.parent);
|
||||
Assert.That(first.transform.parent, Is.EqualTo(null));
|
||||
Assert.That(second.transform.parent, Is.EqualTo(null));
|
||||
|
||||
first.SetParent(second);
|
||||
Assert.AreEqual(second.transform, first.transform.parent);
|
||||
Assert.That(first.transform.parent, Is.EqualTo(second.transform));
|
||||
|
||||
first.transform.SetParent(null!);
|
||||
Assert.AreEqual(null, first.transform.parent);
|
||||
Assert.That(first.transform.parent, Is.EqualTo(null));
|
||||
|
||||
second.SetParent(first);
|
||||
Assert.AreEqual(first.transform, second.transform.parent);
|
||||
Assert.That(second.transform.parent, Is.EqualTo(first.transform));
|
||||
|
||||
yield break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,10 +20,10 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var quaternion = new Quaternion(x, y, z, w);
|
||||
var systemQuaternion = quaternion.ToSystemQuaternion();
|
||||
|
||||
Assert.AreEqual(quaternion.x, systemQuaternion.X, 1e-6f);
|
||||
Assert.AreEqual(quaternion.y, systemQuaternion.Y, 1e-6f);
|
||||
Assert.AreEqual(quaternion.z, systemQuaternion.Z, 1e-6f);
|
||||
Assert.AreEqual(quaternion.w, systemQuaternion.W, 1e-6f);
|
||||
Assert.That(systemQuaternion.X, Is.EqualTo(quaternion.x).Within(1e-6f));
|
||||
Assert.That(systemQuaternion.Y, Is.EqualTo(quaternion.y).Within(1e-6f));
|
||||
Assert.That(systemQuaternion.Z, Is.EqualTo(quaternion.z).Within(1e-6f));
|
||||
Assert.That(systemQuaternion.W, Is.EqualTo(quaternion.w).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -38,10 +38,10 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var quaternion = new System.Numerics.Quaternion(x, y, z, w);
|
||||
var unityQuaternion = quaternion.ToUnityQuaternion();
|
||||
|
||||
Assert.AreEqual(quaternion.X, unityQuaternion.x, 1e-6f);
|
||||
Assert.AreEqual(quaternion.Y, unityQuaternion.y, 1e-6f);
|
||||
Assert.AreEqual(quaternion.Z, unityQuaternion.z, 1e-6f);
|
||||
Assert.AreEqual(quaternion.W, unityQuaternion.w, 1e-6f);
|
||||
Assert.That(unityQuaternion.x, Is.EqualTo(quaternion.X).Within(1e-6f));
|
||||
Assert.That(unityQuaternion.y, Is.EqualTo(quaternion.Y).Within(1e-6f));
|
||||
Assert.That(unityQuaternion.z, Is.EqualTo(quaternion.Z).Within(1e-6f));
|
||||
Assert.That(unityQuaternion.w, Is.EqualTo(quaternion.W).Within(1e-6f));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ namespace X10D.Unity.Tests.Numerics
|
|||
{
|
||||
var random = new Random();
|
||||
var vector = random.NextUnitVector2();
|
||||
Assert.AreEqual(1, vector.magnitude, 1e-6);
|
||||
Assert.That(vector.magnitude, Is.EqualTo(1).Within(1e-6));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -28,7 +28,7 @@ namespace X10D.Unity.Tests.Numerics
|
|||
{
|
||||
var random = new Random();
|
||||
var vector = random.NextUnitVector3();
|
||||
Assert.AreEqual(1, vector.magnitude, 1e-6);
|
||||
Assert.That(vector.magnitude, Is.EqualTo(1).Within(1e-6));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
|
|||
|
|
@ -13,8 +13,8 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector2Int(1, 2);
|
||||
(int x, int y) = vector;
|
||||
|
||||
Assert.AreEqual(1, x);
|
||||
Assert.AreEqual(2, y);
|
||||
Assert.That(x, Is.EqualTo(1));
|
||||
Assert.That(y, Is.EqualTo(2));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -27,8 +27,8 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector2Int(x, y);
|
||||
var point = vector.ToSystemPoint();
|
||||
|
||||
Assert.AreEqual(vector.x, point.X);
|
||||
Assert.AreEqual(vector.y, point.Y);
|
||||
Assert.That(point.X, Is.EqualTo(vector.x));
|
||||
Assert.That(point.Y, Is.EqualTo(vector.y));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -41,36 +41,36 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector2Int(x, y);
|
||||
var point = vector.ToSystemSize();
|
||||
|
||||
Assert.AreEqual(vector.x, point.Width);
|
||||
Assert.AreEqual(vector.y, point.Height);
|
||||
Assert.That(point.Width, Is.EqualTo(vector.x));
|
||||
Assert.That(point.Height, Is.EqualTo(vector.y));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithX_ShouldReturnVectorWithNewX_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(Vector2Int.up, Vector2Int.one.WithX(0));
|
||||
Assert.AreEqual(Vector2Int.zero, Vector2Int.zero.WithX(0));
|
||||
Assert.AreEqual(Vector2Int.zero, Vector2Int.right.WithX(0));
|
||||
Assert.AreEqual(Vector2Int.up, Vector2Int.up.WithX(0));
|
||||
Assert.That(Vector2Int.one.WithX(0), Is.EqualTo(Vector2Int.up));
|
||||
Assert.That(Vector2Int.zero.WithX(0), Is.EqualTo(Vector2Int.zero));
|
||||
Assert.That(Vector2Int.right.WithX(0), Is.EqualTo(Vector2Int.zero));
|
||||
Assert.That(Vector2Int.up.WithX(0), Is.EqualTo(Vector2Int.up));
|
||||
|
||||
Assert.AreEqual(Vector2Int.one, Vector2Int.one.WithX(1));
|
||||
Assert.AreEqual(Vector2Int.right, Vector2Int.zero.WithX(1));
|
||||
Assert.AreEqual(Vector2Int.right, Vector2Int.right.WithX(1));
|
||||
Assert.AreEqual(Vector2Int.one, Vector2Int.up.WithX(1));
|
||||
Assert.That(Vector2Int.one.WithX(1), Is.EqualTo(Vector2Int.one));
|
||||
Assert.That(Vector2Int.zero.WithX(1), Is.EqualTo(Vector2Int.right));
|
||||
Assert.That(Vector2Int.right.WithX(1), Is.EqualTo(Vector2Int.right));
|
||||
Assert.That(Vector2Int.up.WithX(1), Is.EqualTo(Vector2Int.one));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithY_ShouldReturnVectorWithNewY_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(Vector2Int.right, Vector2Int.one.WithY(0));
|
||||
Assert.AreEqual(Vector2Int.zero, Vector2Int.zero.WithY(0));
|
||||
Assert.AreEqual(Vector2Int.right, Vector2Int.right.WithY(0));
|
||||
Assert.AreEqual(Vector2Int.zero, Vector2Int.up.WithY(0));
|
||||
Assert.That(Vector2Int.one.WithY(0), Is.EqualTo(Vector2Int.right));
|
||||
Assert.That(Vector2Int.zero.WithY(0), Is.EqualTo(Vector2Int.zero));
|
||||
Assert.That(Vector2Int.right.WithY(0), Is.EqualTo(Vector2Int.right));
|
||||
Assert.That(Vector2Int.up.WithY(0), Is.EqualTo(Vector2Int.zero));
|
||||
|
||||
Assert.AreEqual(Vector2Int.one, Vector2Int.one.WithY(1));
|
||||
Assert.AreEqual(Vector2Int.up, Vector2Int.zero.WithY(1));
|
||||
Assert.AreEqual(Vector2Int.one, Vector2Int.right.WithY(1));
|
||||
Assert.AreEqual(Vector2Int.up, Vector2Int.up.WithY(1));
|
||||
Assert.That(Vector2Int.one.WithY(1), Is.EqualTo(Vector2Int.one));
|
||||
Assert.That(Vector2Int.zero.WithY(1), Is.EqualTo(Vector2Int.up));
|
||||
Assert.That(Vector2Int.right.WithY(1), Is.EqualTo(Vector2Int.one));
|
||||
Assert.That(Vector2Int.up.WithY(1), Is.EqualTo(Vector2Int.up));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,8 +14,8 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector2(1, 2);
|
||||
(float x, float y) = vector;
|
||||
|
||||
Assert.AreEqual(1, x);
|
||||
Assert.AreEqual(2, y);
|
||||
Assert.That(x, Is.EqualTo(1));
|
||||
Assert.That(y, Is.EqualTo(2));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -24,8 +24,8 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector2(1.5f, 2.6f);
|
||||
var rounded = vector.Round();
|
||||
|
||||
Assert.AreEqual(2, rounded.x);
|
||||
Assert.AreEqual(3, rounded.y);
|
||||
Assert.That(rounded.x, Is.EqualTo(2));
|
||||
Assert.That(rounded.y, Is.EqualTo(3));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -34,8 +34,8 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector2(1.5f, 25.2f);
|
||||
var rounded = vector.Round(10);
|
||||
|
||||
Assert.AreEqual(0, rounded.x);
|
||||
Assert.AreEqual(30, rounded.y);
|
||||
Assert.That(rounded.x, Is.EqualTo(0));
|
||||
Assert.That(rounded.y, Is.EqualTo(30));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -48,8 +48,8 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector2(x, y);
|
||||
var point = vector.ToSystemPointF();
|
||||
|
||||
Assert.AreEqual(vector.x, point.X, 1e-6f);
|
||||
Assert.AreEqual(vector.y, point.Y, 1e-6f);
|
||||
Assert.That(point.X, Is.EqualTo(vector.x).Within(1e-6f));
|
||||
Assert.That(point.Y, Is.EqualTo(vector.y).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -62,8 +62,8 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector2(x, y);
|
||||
var point = vector.ToSystemSizeF();
|
||||
|
||||
Assert.AreEqual(vector.x, point.Width, 1e-6f);
|
||||
Assert.AreEqual(vector.y, point.Height, 1e-6f);
|
||||
Assert.That(point.Width, Is.EqualTo(vector.x).Within(1e-6f));
|
||||
Assert.That(point.Height, Is.EqualTo(vector.y).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -76,9 +76,9 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector2(x, y);
|
||||
var systemVector = vector.ToSystemVector();
|
||||
|
||||
Assert.AreEqual(vector.magnitude, systemVector.Length(), 1e-6f);
|
||||
Assert.AreEqual(vector.x, systemVector.X, 1e-6f);
|
||||
Assert.AreEqual(vector.y, systemVector.Y, 1e-6f);
|
||||
Assert.That(systemVector.Length(), Is.EqualTo(vector.magnitude).Within(1e-6f));
|
||||
Assert.That(systemVector.X, Is.EqualTo(vector.x).Within(1e-6f));
|
||||
Assert.That(systemVector.Y, Is.EqualTo(vector.y).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -91,37 +91,37 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new System.Numerics.Vector2(x, y);
|
||||
var unityVector = vector.ToUnityVector();
|
||||
|
||||
Assert.AreEqual(vector.Length(), unityVector.magnitude, 1e-6f);
|
||||
Assert.AreEqual(vector.X, unityVector.x, 1e-6f);
|
||||
Assert.AreEqual(vector.Y, unityVector.y, 1e-6f);
|
||||
Assert.That(unityVector.magnitude, Is.EqualTo(vector.Length()).Within(1e-6f));
|
||||
Assert.That(unityVector.x, Is.EqualTo(vector.X).Within(1e-6f));
|
||||
Assert.That(unityVector.y, Is.EqualTo(vector.Y).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithX_ShouldReturnVectorWithNewX_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(Vector2.up, Vector2.one.WithX(0));
|
||||
Assert.AreEqual(Vector2.zero, Vector2.zero.WithX(0));
|
||||
Assert.AreEqual(Vector2.zero, Vector2.right.WithX(0));
|
||||
Assert.AreEqual(Vector2.up, Vector2.up.WithX(0));
|
||||
Assert.That(Vector2.one.WithX(0), Is.EqualTo(Vector2.up));
|
||||
Assert.That(Vector2.zero.WithX(0), Is.EqualTo(Vector2.zero));
|
||||
Assert.That(Vector2.right.WithX(0), Is.EqualTo(Vector2.zero));
|
||||
Assert.That(Vector2.up.WithX(0), Is.EqualTo(Vector2.up));
|
||||
|
||||
Assert.AreEqual(Vector2.one, Vector2.one.WithX(1));
|
||||
Assert.AreEqual(Vector2.right, Vector2.zero.WithX(1));
|
||||
Assert.AreEqual(Vector2.right, Vector2.right.WithX(1));
|
||||
Assert.AreEqual(Vector2.one, Vector2.up.WithX(1));
|
||||
Assert.That(Vector2.one.WithX(1), Is.EqualTo(Vector2.one));
|
||||
Assert.That(Vector2.zero.WithX(1), Is.EqualTo(Vector2.right));
|
||||
Assert.That(Vector2.right.WithX(1), Is.EqualTo(Vector2.right));
|
||||
Assert.That(Vector2.up.WithX(1), Is.EqualTo(Vector2.one));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithY_ShouldReturnVectorWithNewY_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(Vector2.right, Vector2.one.WithY(0));
|
||||
Assert.AreEqual(Vector2.zero, Vector2.zero.WithY(0));
|
||||
Assert.AreEqual(Vector2.right, Vector2.right.WithY(0));
|
||||
Assert.AreEqual(Vector2.zero, Vector2.up.WithY(0));
|
||||
Assert.That(Vector2.one.WithY(0), Is.EqualTo(Vector2.right));
|
||||
Assert.That(Vector2.zero.WithY(0), Is.EqualTo(Vector2.zero));
|
||||
Assert.That(Vector2.right.WithY(0), Is.EqualTo(Vector2.right));
|
||||
Assert.That(Vector2.up.WithY(0), Is.EqualTo(Vector2.zero));
|
||||
|
||||
Assert.AreEqual(Vector2.one, Vector2.one.WithY(1));
|
||||
Assert.AreEqual(Vector2.up, Vector2.zero.WithY(1));
|
||||
Assert.AreEqual(Vector2.one, Vector2.right.WithY(1));
|
||||
Assert.AreEqual(Vector2.up, Vector2.up.WithY(1));
|
||||
Assert.That(Vector2.one.WithY(1), Is.EqualTo(Vector2.one));
|
||||
Assert.That(Vector2.zero.WithY(1), Is.EqualTo(Vector2.up));
|
||||
Assert.That(Vector2.right.WithY(1), Is.EqualTo(Vector2.one));
|
||||
Assert.That(Vector2.up.WithY(1), Is.EqualTo(Vector2.up));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,57 +12,58 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector3Int(1, 2, 3);
|
||||
(float x, float y, float z) = vector;
|
||||
|
||||
Assert.AreEqual(1, x);
|
||||
Assert.AreEqual(2, y);
|
||||
Assert.AreEqual(3, z);
|
||||
Assert.That(x, Is.EqualTo(1));
|
||||
Assert.That(y, Is.EqualTo(2));
|
||||
Assert.That(z, Is.EqualTo(3));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithX_ShouldReturnVectorWithNewX_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(new Vector3Int(0, 1, 1), Vector3Int.one.WithX(0));
|
||||
Assert.AreEqual(Vector3Int.zero, Vector3Int.zero.WithX(0));
|
||||
Assert.AreEqual(Vector3Int.zero, Vector3Int.right.WithX(0));
|
||||
Assert.AreEqual(Vector3Int.up, Vector3Int.up.WithX(0));
|
||||
Assert.AreEqual(Vector3Int.forward, Vector3Int.forward.WithX(0));
|
||||
Assert.That(Vector3Int.one.WithX(0), Is.EqualTo(new Vector3Int(0, 1, 1)));
|
||||
Assert.That(Vector3Int.zero.WithX(0), Is.EqualTo(Vector3Int.zero));
|
||||
Assert.That(Vector3Int.right.WithX(0), Is.EqualTo(Vector3Int.zero));
|
||||
Assert.That(Vector3Int.up.WithX(0), Is.EqualTo(Vector3Int.up));
|
||||
Assert.That(Vector3Int.forward.WithX(0), Is.EqualTo(Vector3Int.forward));
|
||||
|
||||
Assert.AreEqual(Vector3Int.one, Vector3Int.one.WithX(1));
|
||||
Assert.AreEqual(Vector3Int.right, Vector3Int.zero.WithX(1));
|
||||
Assert.AreEqual(Vector3Int.right, Vector3Int.right.WithX(1));
|
||||
Assert.AreEqual(new Vector3Int(1, 1, 0), Vector3Int.up.WithX(1));
|
||||
Assert.AreEqual(new Vector3Int(1, 0, 1), Vector3Int.forward.WithX(1));
|
||||
Assert.That(Vector3Int.one.WithX(1), Is.EqualTo(Vector3Int.one));
|
||||
Assert.That(Vector3Int.zero.WithX(1), Is.EqualTo(Vector3Int.right));
|
||||
Assert.That(Vector3Int.right.WithX(1), Is.EqualTo(Vector3Int.right));
|
||||
Assert.That(Vector3Int.up.WithX(1), Is.EqualTo(new Vector3Int(1, 1, 0)));
|
||||
Assert.That(Vector3Int.forward.WithX(1), Is.EqualTo(new Vector3Int(1, 0, 1)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithY_ShouldReturnVectorWithNewY_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(new Vector3Int(1, 0, 1), Vector3Int.one.WithY(0));
|
||||
Assert.AreEqual(Vector3Int.zero, Vector3Int.zero.WithY(0));
|
||||
Assert.AreEqual(Vector3Int.right, Vector3Int.right.WithY(0));
|
||||
Assert.AreEqual(Vector3Int.zero, Vector3Int.up.WithY(0));
|
||||
Assert.AreEqual(Vector3Int.forward, Vector3Int.forward.WithY(0));
|
||||
Assert.That(Vector3Int.one.WithY(0), Is.EqualTo(new Vector3Int(1, 0, 1)));
|
||||
Assert.That(Vector3Int.zero.WithY(0), Is.EqualTo(Vector3Int.zero));
|
||||
Assert.That(Vector3Int.right.WithY(0), Is.EqualTo(Vector3Int.right));
|
||||
Assert.That(Vector3Int.up.WithY(0), Is.EqualTo(Vector3Int.zero));
|
||||
Assert.That(Vector3Int.forward.WithY(0), Is.EqualTo(Vector3Int.forward));
|
||||
|
||||
Assert.AreEqual(Vector3Int.one, Vector3Int.one.WithY(1));
|
||||
Assert.AreEqual(Vector3Int.up, Vector3Int.zero.WithY(1));
|
||||
Assert.AreEqual(new Vector3Int(1, 1, 0), Vector3Int.right.WithY(1));
|
||||
Assert.AreEqual(Vector3Int.up, Vector3Int.up.WithY(1));
|
||||
Assert.AreEqual(new Vector3Int(0, 1, 1), Vector3Int.forward.WithY(1));
|
||||
Assert.That(Vector3Int.one.WithY(1), Is.EqualTo(Vector3Int.one));
|
||||
Assert.That(Vector3Int.zero.WithY(1), Is.EqualTo(Vector3Int.up));
|
||||
Assert.That(Vector3Int.right.WithY(1), Is.EqualTo(new Vector3Int(1, 1, 0)));
|
||||
Assert.That(Vector3Int.up.WithY(1), Is.EqualTo(Vector3Int.up));
|
||||
Assert.That(Vector3Int.forward.WithY(1), Is.EqualTo(new Vector3Int(0, 1, 1)));
|
||||
;
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithZ_ShouldReturnVectorWithNewZ_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(new Vector3Int(1, 1, 0), Vector3Int.one.WithZ(0));
|
||||
Assert.AreEqual(Vector3Int.zero, Vector3Int.zero.WithZ(0));
|
||||
Assert.AreEqual(Vector3Int.right, Vector3Int.right.WithZ(0));
|
||||
Assert.AreEqual(Vector3Int.up, Vector3Int.up.WithZ(0));
|
||||
Assert.AreEqual(Vector3Int.zero, Vector3Int.forward.WithZ(0));
|
||||
Assert.That(Vector3Int.one.WithZ(0), Is.EqualTo(new Vector3Int(1, 1, 0)));
|
||||
Assert.That(Vector3Int.zero.WithZ(0), Is.EqualTo(Vector3Int.zero));
|
||||
Assert.That(Vector3Int.right.WithZ(0), Is.EqualTo(Vector3Int.right));
|
||||
Assert.That(Vector3Int.up.WithZ(0), Is.EqualTo(Vector3Int.up));
|
||||
Assert.That(Vector3Int.forward.WithZ(0), Is.EqualTo(Vector3Int.zero));
|
||||
|
||||
Assert.AreEqual(Vector3Int.one, Vector3Int.one.WithZ(1));
|
||||
Assert.AreEqual(Vector3Int.forward, Vector3Int.zero.WithZ(1));
|
||||
Assert.AreEqual(new Vector3Int(1, 0, 1), Vector3Int.right.WithZ(1));
|
||||
Assert.AreEqual(new Vector3Int(0, 1, 1), Vector3Int.up.WithZ(1));
|
||||
Assert.AreEqual(Vector3Int.forward, Vector3Int.forward.WithZ(1));
|
||||
Assert.That(Vector3Int.one.WithZ(1), Is.EqualTo(Vector3Int.one));
|
||||
Assert.That(Vector3Int.zero.WithZ(1), Is.EqualTo(Vector3Int.forward));
|
||||
Assert.That(Vector3Int.right.WithZ(1), Is.EqualTo(new Vector3Int(1, 0, 1)));
|
||||
Assert.That(Vector3Int.up.WithZ(1), Is.EqualTo(new Vector3Int(0, 1, 1)));
|
||||
Assert.That(Vector3Int.forward.WithZ(1), Is.EqualTo(Vector3Int.forward));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,9 +14,9 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector3(1, 2, 3);
|
||||
(float x, float y, float z) = vector;
|
||||
|
||||
Assert.AreEqual(1, x);
|
||||
Assert.AreEqual(2, y);
|
||||
Assert.AreEqual(3, z);
|
||||
Assert.That(x, Is.EqualTo(1));
|
||||
Assert.That(y, Is.EqualTo(2));
|
||||
Assert.That(z, Is.EqualTo(3));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -25,9 +25,9 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector3(1.5f, 2.6f, -5.2f);
|
||||
var rounded = vector.Round();
|
||||
|
||||
Assert.AreEqual(2, rounded.x);
|
||||
Assert.AreEqual(3, rounded.y);
|
||||
Assert.AreEqual(-5, rounded.z);
|
||||
Assert.That(rounded.x, Is.EqualTo(2));
|
||||
Assert.That(rounded.y, Is.EqualTo(3));
|
||||
Assert.That(rounded.z, Is.EqualTo(-5));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -36,9 +36,9 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector3(1.5f, 25.2f, -12.5f);
|
||||
var rounded = vector.Round(10);
|
||||
|
||||
Assert.AreEqual(0, rounded.x);
|
||||
Assert.AreEqual(30, rounded.y);
|
||||
Assert.AreEqual(-10, rounded.z);
|
||||
Assert.That(rounded.x, Is.EqualTo(0));
|
||||
Assert.That(rounded.y, Is.EqualTo(30));
|
||||
Assert.That(rounded.z, Is.EqualTo(-10));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -52,10 +52,10 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector3(x, y, z);
|
||||
var systemVector = vector.ToSystemVector();
|
||||
|
||||
Assert.AreEqual(vector.magnitude, systemVector.Length(), 1e-6f);
|
||||
Assert.AreEqual(vector.x, systemVector.X, 1e-6f);
|
||||
Assert.AreEqual(vector.y, systemVector.Y, 1e-6f);
|
||||
Assert.AreEqual(vector.z, systemVector.Z, 1e-6f);
|
||||
Assert.That(systemVector.Length(), Is.EqualTo(vector.magnitude).Within(1e-6f));
|
||||
Assert.That(systemVector.X, Is.EqualTo(vector.x).Within(1e-6f));
|
||||
Assert.That(systemVector.Y, Is.EqualTo(vector.y).Within(1e-6f));
|
||||
Assert.That(systemVector.Z, Is.EqualTo(vector.z).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -69,58 +69,58 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new System.Numerics.Vector3(x, y, z);
|
||||
var unityVector = vector.ToUnityVector();
|
||||
|
||||
Assert.AreEqual(vector.Length(), unityVector.magnitude, 1e-6f);
|
||||
Assert.AreEqual(vector.X, unityVector.x, 1e-6f);
|
||||
Assert.AreEqual(vector.Y, unityVector.y, 1e-6f);
|
||||
Assert.AreEqual(vector.Z, unityVector.z, 1e-6f);
|
||||
Assert.That(unityVector.magnitude, Is.EqualTo(vector.Length()).Within(1e-6f));
|
||||
Assert.That(unityVector.x, Is.EqualTo(vector.X).Within(1e-6f));
|
||||
Assert.That(unityVector.y, Is.EqualTo(vector.Y).Within(1e-6f));
|
||||
Assert.That(unityVector.z, Is.EqualTo(vector.Z).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithX_ShouldReturnVectorWithNewX_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(new Vector3(0, 1, 1), Vector3.one.WithX(0));
|
||||
Assert.AreEqual(Vector3.zero, Vector3.zero.WithX(0));
|
||||
Assert.AreEqual(Vector3.zero, Vector3.right.WithX(0));
|
||||
Assert.AreEqual(Vector3.up, Vector3.up.WithX(0));
|
||||
Assert.AreEqual(Vector3.forward, Vector3.forward.WithX(0));
|
||||
Assert.That(Vector3.one.WithX(0), Is.EqualTo(new Vector3(0, 1, 1)));
|
||||
Assert.That(Vector3.zero.WithX(0), Is.EqualTo(Vector3.zero));
|
||||
Assert.That(Vector3.right.WithX(0), Is.EqualTo(Vector3.zero));
|
||||
Assert.That(Vector3.up.WithX(0), Is.EqualTo(Vector3.up));
|
||||
Assert.That(Vector3.forward.WithX(0), Is.EqualTo(Vector3.forward));
|
||||
|
||||
Assert.AreEqual(Vector3.one, Vector3.one.WithX(1));
|
||||
Assert.AreEqual(Vector3.right, Vector3.zero.WithX(1));
|
||||
Assert.AreEqual(Vector3.right, Vector3.right.WithX(1));
|
||||
Assert.AreEqual(new Vector3(1, 1, 0), Vector3.up.WithX(1));
|
||||
Assert.AreEqual(new Vector3(1, 0, 1), Vector3.forward.WithX(1));
|
||||
Assert.That(Vector3.one.WithX(1), Is.EqualTo(Vector3.one));
|
||||
Assert.That(Vector3.zero.WithX(1), Is.EqualTo(Vector3.right));
|
||||
Assert.That(Vector3.right.WithX(1), Is.EqualTo(Vector3.right));
|
||||
Assert.That(Vector3.up.WithX(1), Is.EqualTo(new Vector3(1, 1, 0)));
|
||||
Assert.That(Vector3.forward.WithX(1), Is.EqualTo(new Vector3(1, 0, 1)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithY_ShouldReturnVectorWithNewY_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(new Vector3(1, 0, 1), Vector3.one.WithY(0));
|
||||
Assert.AreEqual(Vector3.zero, Vector3.zero.WithY(0));
|
||||
Assert.AreEqual(Vector3.right, Vector3.right.WithY(0));
|
||||
Assert.AreEqual(Vector3.zero, Vector3.up.WithY(0));
|
||||
Assert.AreEqual(Vector3.forward, Vector3.forward.WithY(0));
|
||||
Assert.That(Vector3.one.WithY(0), Is.EqualTo(new Vector3(1, 0, 1)));
|
||||
Assert.That(Vector3.zero.WithY(0), Is.EqualTo(Vector3.zero));
|
||||
Assert.That(Vector3.right.WithY(0), Is.EqualTo(Vector3.right));
|
||||
Assert.That(Vector3.up.WithY(0), Is.EqualTo(Vector3.zero));
|
||||
Assert.That(Vector3.forward.WithY(0), Is.EqualTo(Vector3.forward));
|
||||
|
||||
Assert.AreEqual(Vector3.one, Vector3.one.WithY(1));
|
||||
Assert.AreEqual(Vector3.up, Vector3.zero.WithY(1));
|
||||
Assert.AreEqual(new Vector3(1, 1, 0), Vector3.right.WithY(1));
|
||||
Assert.AreEqual(Vector3.up, Vector3.up.WithY(1));
|
||||
Assert.AreEqual(new Vector3(0, 1, 1), Vector3.forward.WithY(1));
|
||||
Assert.That(Vector3.one.WithY(1), Is.EqualTo(Vector3.one));
|
||||
Assert.That(Vector3.zero.WithY(1), Is.EqualTo(Vector3.up));
|
||||
Assert.That(Vector3.right.WithY(1), Is.EqualTo(new Vector3(1, 1, 0)));
|
||||
Assert.That(Vector3.up.WithY(1), Is.EqualTo(Vector3.up));
|
||||
Assert.That(Vector3.forward.WithY(1), Is.EqualTo(new Vector3(0, 1, 1)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithZ_ShouldReturnVectorWithNewZ_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(new Vector3(1, 1, 0), Vector3.one.WithZ(0));
|
||||
Assert.AreEqual(Vector3.zero, Vector3.zero.WithZ(0));
|
||||
Assert.AreEqual(Vector3.right, Vector3.right.WithZ(0));
|
||||
Assert.AreEqual(Vector3.up, Vector3.up.WithZ(0));
|
||||
Assert.AreEqual(Vector3.zero, Vector3.forward.WithZ(0));
|
||||
Assert.That(Vector3.one.WithZ(0), Is.EqualTo(new Vector3(1, 1, 0)));
|
||||
Assert.That(Vector3.zero.WithZ(0), Is.EqualTo(Vector3.zero));
|
||||
Assert.That(Vector3.right.WithZ(0), Is.EqualTo(Vector3.right));
|
||||
Assert.That(Vector3.up.WithZ(0), Is.EqualTo(Vector3.up));
|
||||
Assert.That(Vector3.forward.WithZ(0), Is.EqualTo(Vector3.zero));
|
||||
|
||||
Assert.AreEqual(Vector3.one, Vector3.one.WithZ(1));
|
||||
Assert.AreEqual(Vector3.forward, Vector3.zero.WithZ(1));
|
||||
Assert.AreEqual(new Vector3(1, 0, 1), Vector3.right.WithZ(1));
|
||||
Assert.AreEqual(new Vector3(0, 1, 1), Vector3.up.WithZ(1));
|
||||
Assert.AreEqual(Vector3.forward, Vector3.forward.WithZ(1));
|
||||
Assert.That(Vector3.one.WithZ(1), Is.EqualTo(Vector3.one));
|
||||
Assert.That(Vector3.zero.WithZ(1), Is.EqualTo(Vector3.forward));
|
||||
Assert.That(Vector3.right.WithZ(1), Is.EqualTo(new Vector3(1, 0, 1)));
|
||||
Assert.That(Vector3.up.WithZ(1), Is.EqualTo(new Vector3(0, 1, 1)));
|
||||
Assert.That(Vector3.forward.WithZ(1), Is.EqualTo(Vector3.forward));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,10 +14,10 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector4(1, 2, 3, 4);
|
||||
(float x, float y, float z, float w) = vector;
|
||||
|
||||
Assert.AreEqual(1, x);
|
||||
Assert.AreEqual(2, y);
|
||||
Assert.AreEqual(3, z);
|
||||
Assert.AreEqual(4, w);
|
||||
Assert.That(x, Is.EqualTo(1));
|
||||
Assert.That(y, Is.EqualTo(2));
|
||||
Assert.That(z, Is.EqualTo(3));
|
||||
Assert.That(w, Is.EqualTo(4));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -26,10 +26,10 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector4(1.5f, 2.6f, -5.2f, 0.3f);
|
||||
var rounded = vector.Round();
|
||||
|
||||
Assert.AreEqual(2, rounded.x);
|
||||
Assert.AreEqual(3, rounded.y);
|
||||
Assert.AreEqual(-5, rounded.z);
|
||||
Assert.AreEqual(0, rounded.w);
|
||||
Assert.That(rounded.x, Is.EqualTo(2));
|
||||
Assert.That(rounded.y, Is.EqualTo(3));
|
||||
Assert.That(rounded.z, Is.EqualTo(-5));
|
||||
Assert.That(rounded.w, Is.EqualTo(0));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -38,10 +38,10 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector4(1.5f, 25.2f, -12.5f, 101.2f);
|
||||
var rounded = vector.Round(10);
|
||||
|
||||
Assert.AreEqual(0, rounded.x);
|
||||
Assert.AreEqual(30, rounded.y);
|
||||
Assert.AreEqual(-10, rounded.z);
|
||||
Assert.AreEqual(100, rounded.w);
|
||||
Assert.That(rounded.x, Is.EqualTo(0));
|
||||
Assert.That(rounded.y, Is.EqualTo(30));
|
||||
Assert.That(rounded.z, Is.EqualTo(-10));
|
||||
Assert.That(rounded.w, Is.EqualTo(100));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -56,11 +56,11 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new Vector4(x, y, z, w);
|
||||
var systemVector = vector.ToSystemVector();
|
||||
|
||||
Assert.AreEqual(vector.magnitude, systemVector.Length(), 1e-6f);
|
||||
Assert.AreEqual(vector.x, systemVector.X, 1e-6f);
|
||||
Assert.AreEqual(vector.y, systemVector.Y, 1e-6f);
|
||||
Assert.AreEqual(vector.z, systemVector.Z, 1e-6f);
|
||||
Assert.AreEqual(vector.w, systemVector.W, 1e-6f);
|
||||
Assert.That(systemVector.Length(), Is.EqualTo(vector.magnitude).Within(1e-6f));
|
||||
Assert.That(systemVector.X, Is.EqualTo(vector.x).Within(1e-6f));
|
||||
Assert.That(systemVector.Y, Is.EqualTo(vector.y).Within(1e-6f));
|
||||
Assert.That(systemVector.Z, Is.EqualTo(vector.z).Within(1e-6f));
|
||||
Assert.That(systemVector.W, Is.EqualTo(vector.w).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
|
|
@ -75,83 +75,83 @@ namespace X10D.Unity.Tests.Numerics
|
|||
var vector = new System.Numerics.Vector4(x, y, z, w);
|
||||
var unityVector = vector.ToUnityVector();
|
||||
|
||||
Assert.AreEqual(vector.Length(), unityVector.magnitude, 1e-6f);
|
||||
Assert.AreEqual(vector.X, unityVector.x, 1e-6f);
|
||||
Assert.AreEqual(vector.Y, unityVector.y, 1e-6f);
|
||||
Assert.AreEqual(vector.Z, unityVector.z, 1e-6f);
|
||||
Assert.AreEqual(vector.W, unityVector.w, 1e-6f);
|
||||
Assert.That(unityVector.magnitude, Is.EqualTo(vector.Length()).Within(1e-6f));
|
||||
Assert.That(unityVector.x, Is.EqualTo(vector.X).Within(1e-6f));
|
||||
Assert.That(unityVector.y, Is.EqualTo(vector.Y).Within(1e-6f));
|
||||
Assert.That(unityVector.z, Is.EqualTo(vector.Z).Within(1e-6f));
|
||||
Assert.That(unityVector.w, Is.EqualTo(vector.W).Within(1e-6f));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithW_ShouldReturnVectorWithNewW_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(new Vector4(1, 1, 1, 0), Vector4.one.WithW(0));
|
||||
Assert.AreEqual(Vector4.zero, Vector4.zero.WithW(0));
|
||||
Assert.AreEqual(Vector4.zero, new Vector4(0, 0, 0, 1).WithW(0));
|
||||
Assert.AreEqual(new Vector4(1, 0, 0, 0), new Vector4(1, 0, 0, 0).WithW(0));
|
||||
Assert.AreEqual(new Vector4(0, 1, 0, 0), new Vector4(0, 1, 0, 0).WithW(0));
|
||||
Assert.AreEqual(new Vector4(0, 0, 1, 0), new Vector4(0, 0, 1, 0).WithW(0));
|
||||
Assert.That(Vector4.one.WithW(0), Is.EqualTo(new Vector4(1, 1, 1, 0)));
|
||||
Assert.That(Vector4.zero.WithW(0), Is.EqualTo(Vector4.zero));
|
||||
Assert.That(new Vector4(0, 0, 0, 1).WithW(0), Is.EqualTo(Vector4.zero));
|
||||
Assert.That(new Vector4(1, 0, 0, 0).WithW(0), Is.EqualTo(new Vector4(1, 0, 0, 0)));
|
||||
Assert.That(new Vector4(0, 1, 0, 0).WithW(0), Is.EqualTo(new Vector4(0, 1, 0, 0)));
|
||||
Assert.That(new Vector4(0, 0, 1, 0).WithW(0), Is.EqualTo(new Vector4(0, 0, 1, 0)));
|
||||
|
||||
Assert.AreEqual(Vector4.one, Vector4.one.WithW(1));
|
||||
Assert.AreEqual(new Vector4(0, 0, 0, 1), Vector4.zero.WithW(1));
|
||||
Assert.AreEqual(new Vector4(0, 0, 0, 1), new Vector4(0, 0, 0, 1).WithW(1));
|
||||
Assert.AreEqual(new Vector4(1, 0, 0, 1), new Vector4(1, 0, 0, 0).WithW(1));
|
||||
Assert.AreEqual(new Vector4(0, 1, 0, 1), new Vector4(0, 1, 0, 0).WithW(1));
|
||||
Assert.AreEqual(new Vector4(0, 0, 1, 1), new Vector4(0, 0, 1, 0).WithW(1));
|
||||
Assert.That(Vector4.one.WithW(1), Is.EqualTo(Vector4.one));
|
||||
Assert.That(Vector4.zero.WithW(1), Is.EqualTo(new Vector4(0, 0, 0, 1)));
|
||||
Assert.That(new Vector4(0, 0, 0, 1).WithW(1), Is.EqualTo(new Vector4(0, 0, 0, 1)));
|
||||
Assert.That(new Vector4(1, 0, 0, 0).WithW(1), Is.EqualTo(new Vector4(1, 0, 0, 1)));
|
||||
Assert.That(new Vector4(0, 1, 0, 0).WithW(1), Is.EqualTo(new Vector4(0, 1, 0, 1)));
|
||||
Assert.That(new Vector4(0, 0, 1, 0).WithW(1), Is.EqualTo(new Vector4(0, 0, 1, 1)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithX_ShouldReturnVectorWithNewX_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(new Vector4(0, 1, 1, 1), Vector4.one.WithX(0));
|
||||
Assert.AreEqual(Vector4.zero, Vector4.zero.WithX(0));
|
||||
Assert.AreEqual(new Vector4(0, 0, 0, 1), new Vector4(0, 0, 0, 1).WithX(0));
|
||||
Assert.AreEqual(Vector4.zero, new Vector4(1, 0, 0, 0).WithX(0));
|
||||
Assert.AreEqual(new Vector4(0, 1, 0, 0), new Vector4(0, 1, 0, 0).WithX(0));
|
||||
Assert.AreEqual(new Vector4(0, 0, 1, 0), new Vector4(0, 0, 1, 0).WithX(0));
|
||||
Assert.That(Vector4.one.WithX(0), Is.EqualTo(new Vector4(0, 1, 1, 1)));
|
||||
Assert.That(Vector4.zero.WithX(0), Is.EqualTo(Vector4.zero));
|
||||
Assert.That(new Vector4(0, 0, 0, 1).WithX(0), Is.EqualTo(new Vector4(0, 0, 0, 1)));
|
||||
Assert.That(new Vector4(1, 0, 0, 0).WithX(0), Is.EqualTo(Vector4.zero));
|
||||
Assert.That(new Vector4(0, 1, 0, 0).WithX(0), Is.EqualTo(new Vector4(0, 1, 0, 0)));
|
||||
Assert.That(new Vector4(0, 0, 1, 0).WithX(0), Is.EqualTo(new Vector4(0, 0, 1, 0)));
|
||||
|
||||
Assert.AreEqual(Vector4.one, Vector4.one.WithX(1));
|
||||
Assert.AreEqual(new Vector4(1, 0, 0, 0), Vector4.zero.WithX(1));
|
||||
Assert.AreEqual(new Vector4(1, 0, 0, 1), new Vector4(0, 0, 0, 1).WithX(1));
|
||||
Assert.AreEqual(new Vector4(1, 0, 0, 0), new Vector4(1, 0, 0, 0).WithX(1));
|
||||
Assert.AreEqual(new Vector4(1, 1, 0, 0), new Vector4(0, 1, 0, 0).WithX(1));
|
||||
Assert.AreEqual(new Vector4(1, 0, 1, 0), new Vector4(0, 0, 1, 0).WithX(1));
|
||||
Assert.That(Vector4.one.WithX(1), Is.EqualTo(Vector4.one));
|
||||
Assert.That(Vector4.zero.WithX(1), Is.EqualTo(new Vector4(1, 0, 0, 0)));
|
||||
Assert.That(new Vector4(0, 0, 0, 1).WithX(1), Is.EqualTo(new Vector4(1, 0, 0, 1)));
|
||||
Assert.That(new Vector4(1, 0, 0, 0).WithX(1), Is.EqualTo(new Vector4(1, 0, 0, 0)));
|
||||
Assert.That(new Vector4(0, 1, 0, 0).WithX(1), Is.EqualTo(new Vector4(1, 1, 0, 0)));
|
||||
Assert.That(new Vector4(0, 0, 1, 0).WithX(1), Is.EqualTo(new Vector4(1, 0, 1, 0)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithY_ShouldReturnVectorWithNewY_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(new Vector4(1, 0, 1, 1), Vector4.one.WithY(0));
|
||||
Assert.AreEqual(Vector4.zero, Vector4.zero.WithY(0));
|
||||
Assert.AreEqual(new Vector4(0, 0, 0, 1), new Vector4(0, 0, 0, 1).WithY(0));
|
||||
Assert.AreEqual(new Vector4(1, 0, 0, 0), new Vector4(1, 0, 0, 0).WithY(0));
|
||||
Assert.AreEqual(Vector4.zero, new Vector4(0, 1, 0, 0).WithY(0));
|
||||
Assert.AreEqual(new Vector4(0, 0, 1, 0), new Vector4(0, 0, 1, 0).WithY(0));
|
||||
Assert.That(Vector4.one.WithY(0), Is.EqualTo(new Vector4(1, 0, 1, 1)));
|
||||
Assert.That(Vector4.zero.WithY(0), Is.EqualTo(Vector4.zero));
|
||||
Assert.That(new Vector4(0, 0, 0, 1).WithY(0), Is.EqualTo(new Vector4(0, 0, 0, 1)));
|
||||
Assert.That(new Vector4(1, 0, 0, 0).WithY(0), Is.EqualTo(new Vector4(1, 0, 0, 0)));
|
||||
Assert.That(new Vector4(0, 1, 0, 0).WithY(0), Is.EqualTo(Vector4.zero));
|
||||
Assert.That(new Vector4(0, 0, 1, 0).WithY(0), Is.EqualTo(new Vector4(0, 0, 1, 0)));
|
||||
|
||||
Assert.AreEqual(Vector4.one, Vector4.one.WithY(1));
|
||||
Assert.AreEqual(new Vector4(0, 1, 0, 0), Vector4.zero.WithY(1));
|
||||
Assert.AreEqual(new Vector4(0, 1, 0, 1), new Vector4(0, 0, 0, 1).WithY(1));
|
||||
Assert.AreEqual(new Vector4(1, 1, 0, 0), new Vector4(1, 0, 0, 0).WithY(1));
|
||||
Assert.AreEqual(new Vector4(0, 1, 0, 0), new Vector4(0, 1, 0, 0).WithY(1));
|
||||
Assert.AreEqual(new Vector4(0, 1, 1, 0), new Vector4(0, 0, 1, 0).WithY(1));
|
||||
Assert.That(Vector4.one.WithY(1), Is.EqualTo(Vector4.one));
|
||||
Assert.That(Vector4.zero.WithY(1), Is.EqualTo(new Vector4(0, 1, 0, 0)));
|
||||
Assert.That(new Vector4(0, 0, 0, 1).WithY(1), Is.EqualTo(new Vector4(0, 1, 0, 1)));
|
||||
Assert.That(new Vector4(1, 0, 0, 0).WithY(1), Is.EqualTo(new Vector4(1, 1, 0, 0)));
|
||||
Assert.That(new Vector4(0, 1, 0, 0).WithY(1), Is.EqualTo(new Vector4(0, 1, 0, 0)));
|
||||
Assert.That(new Vector4(0, 0, 1, 0).WithY(1), Is.EqualTo(new Vector4(0, 1, 1, 0)));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void WithZ_ShouldReturnVectorWithNewZ_GivenVector()
|
||||
{
|
||||
Assert.AreEqual(new Vector4(1, 1, 0, 1), Vector4.one.WithZ(0));
|
||||
Assert.AreEqual(Vector4.zero, Vector4.zero.WithZ(0));
|
||||
Assert.AreEqual(new Vector4(0, 0, 0, 1), new Vector4(0, 0, 0, 1).WithZ(0));
|
||||
Assert.AreEqual(new Vector4(1, 0, 0, 0), new Vector4(1, 0, 0, 0).WithZ(0));
|
||||
Assert.AreEqual(new Vector4(0, 1, 0, 0), new Vector4(0, 1, 0, 0).WithZ(0));
|
||||
Assert.AreEqual(Vector4.zero, new Vector4(0, 0, 1, 0).WithZ(0));
|
||||
Assert.That(Vector4.one.WithZ(0), Is.EqualTo(new Vector4(1, 1, 0, 1)));
|
||||
Assert.That(Vector4.zero.WithZ(0), Is.EqualTo(Vector4.zero));
|
||||
Assert.That(new Vector4(0, 0, 0, 1).WithZ(0), Is.EqualTo(new Vector4(0, 0, 0, 1)));
|
||||
Assert.That(new Vector4(1, 0, 0, 0).WithZ(0), Is.EqualTo(new Vector4(1, 0, 0, 0)));
|
||||
Assert.That(new Vector4(0, 1, 0, 0).WithZ(0), Is.EqualTo(new Vector4(0, 1, 0, 0)));
|
||||
Assert.That(new Vector4(0, 0, 1, 0).WithZ(0), Is.EqualTo(Vector4.zero));
|
||||
|
||||
Assert.AreEqual(Vector4.one, Vector4.one.WithZ(1));
|
||||
Assert.AreEqual(new Vector4(0, 0, 1, 0), Vector4.zero.WithZ(1));
|
||||
Assert.AreEqual(new Vector4(0, 0, 1, 1), new Vector4(0, 0, 0, 1).WithZ(1));
|
||||
Assert.AreEqual(new Vector4(1, 0, 1, 0), new Vector4(1, 0, 0, 0).WithZ(1));
|
||||
Assert.AreEqual(new Vector4(0, 1, 1, 0), new Vector4(0, 1, 0, 0).WithZ(1));
|
||||
Assert.AreEqual(new Vector4(0, 0, 1, 0), new Vector4(0, 0, 1, 0).WithZ(1));
|
||||
Assert.That(Vector4.one.WithZ(1), Is.EqualTo(Vector4.one));
|
||||
Assert.That(Vector4.zero.WithZ(1), Is.EqualTo(new Vector4(0, 0, 1, 0)));
|
||||
Assert.That(new Vector4(0, 0, 0, 1).WithZ(1), Is.EqualTo(new Vector4(0, 0, 1, 1)));
|
||||
Assert.That(new Vector4(1, 0, 0, 0).WithZ(1), Is.EqualTo(new Vector4(1, 0, 1, 0)));
|
||||
Assert.That(new Vector4(0, 1, 0, 0).WithZ(1), Is.EqualTo(new Vector4(0, 1, 1, 0)));
|
||||
Assert.That(new Vector4(0, 0, 1, 0).WithZ(1), Is.EqualTo(new Vector4(0, 0, 1, 0)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,23 +11,23 @@ namespace X10D.Unity.Tests
|
|||
public void Singleton_ShouldReturnNewInstance_WhenNoInstanceExists()
|
||||
{
|
||||
TestBehaviour instance = Singleton<TestBehaviour>.Instance;
|
||||
Assert.IsNotNull(instance);
|
||||
Assert.IsTrue(instance.Flag);
|
||||
Assert.That(instance, Is.Not.Null);
|
||||
Assert.That(instance.Flag);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Singleton_ShouldReturnSameInstance_WhenAccessedTwice()
|
||||
{
|
||||
TestBehaviour instance = Singleton<TestBehaviour>.Instance;
|
||||
Assert.IsNotNull(instance);
|
||||
Assert.AreEqual(instance, Singleton<TestBehaviour>.Instance);
|
||||
Assert.That(instance, Is.Not.Null);
|
||||
Assert.That(Singleton<TestBehaviour>.Instance, Is.EqualTo(instance));
|
||||
}
|
||||
|
||||
[UnityTest]
|
||||
public IEnumerator Singleton_ShouldReturnNewInstance_WhenDestroyed()
|
||||
{
|
||||
TestBehaviour instance = Singleton<TestBehaviour>.Instance;
|
||||
Assert.IsNotNull(instance);
|
||||
Assert.That(instance, Is.Not.Null);
|
||||
Object.Destroy(instance);
|
||||
|
||||
yield return null;
|
||||
|
|
@ -36,7 +36,7 @@ namespace X10D.Unity.Tests
|
|||
|
||||
// ReSharper disable once HeuristicUnreachableCode
|
||||
instance = Singleton<TestBehaviour>.Instance;
|
||||
Assert.IsNotNull(instance);
|
||||
Assert.That(instance, Is.Not.Null);
|
||||
Assert.IsTrue(instance.Flag);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,20 +17,20 @@ namespace X10D.Unity.Tests
|
|||
Transform firstTransform = first.transform;
|
||||
Transform secondTransform = second.transform;
|
||||
|
||||
Assert.AreEqual(Quaternion.identity, firstTransform.rotation);
|
||||
Assert.AreEqual(Quaternion.identity, secondTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(Quaternion.identity));
|
||||
Assert.That(secondTransform.rotation, Is.EqualTo(Quaternion.identity));
|
||||
|
||||
firstTransform.LookAt(secondTransform);
|
||||
Quaternion expected = firstTransform.rotation;
|
||||
|
||||
firstTransform.rotation = Quaternion.identity;
|
||||
Assert.AreEqual(Quaternion.identity, firstTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(Quaternion.identity));
|
||||
|
||||
firstTransform.LookAt(second);
|
||||
Assert.AreEqual(expected, firstTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(expected));
|
||||
|
||||
firstTransform.rotation = Quaternion.identity;
|
||||
Assert.AreEqual(Quaternion.identity, firstTransform.rotation);
|
||||
Assert.That(firstTransform.rotation, Is.EqualTo(Quaternion.identity));
|
||||
|
||||
yield break;
|
||||
}
|
||||
|
|
@ -41,17 +41,17 @@ namespace X10D.Unity.Tests
|
|||
var first = new GameObject {transform = {position = Vector3.zero, rotation = Quaternion.identity}};
|
||||
var second = new GameObject {transform = {position = Vector3.right, rotation = Quaternion.identity}};
|
||||
|
||||
Assert.AreEqual(null, first.transform.parent);
|
||||
Assert.AreEqual(null, second.transform.parent);
|
||||
Assert.That(first.transform.parent, Is.EqualTo(null));
|
||||
Assert.That(second.transform.parent, Is.EqualTo(null));
|
||||
|
||||
first.transform.SetParent(second);
|
||||
Assert.AreEqual(second.transform, first.transform.parent);
|
||||
Assert.That(first.transform.parent, Is.EqualTo(second.transform));
|
||||
|
||||
first.transform.SetParent(null!);
|
||||
Assert.AreEqual(null, first.transform.parent);
|
||||
Assert.That(first.transform.parent, Is.EqualTo(null));
|
||||
|
||||
second.transform.SetParent(first);
|
||||
Assert.AreEqual(first.transform, second.transform.parent);
|
||||
Assert.That(second.transform.parent, Is.EqualTo(first.transform));
|
||||
|
||||
yield break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ namespace X10D.Unity.Tests
|
|||
{
|
||||
int frameCount = UTime.frameCount;
|
||||
yield return new WaitForFrames(10);
|
||||
Assert.AreEqual(frameCount + 10, UTime.frameCount, $"{frameCount + 10} == {UTime.frameCount}");
|
||||
Assert.That(UTime.frameCount, Is.EqualTo(frameCount + 10), $"{frameCount + 10} == {UTime.frameCount}");
|
||||
}
|
||||
|
||||
[UnityTest]
|
||||
|
|
@ -22,7 +22,7 @@ namespace X10D.Unity.Tests
|
|||
{
|
||||
float time = UTime.time;
|
||||
yield return new WaitForSecondsNoAlloc(2);
|
||||
Assert.AreEqual(time + 2, UTime.time, 1e-2, $"{time + 2} == {UTime.time}");
|
||||
Assert.That(UTime.time, Is.EqualTo(time + 2).Within(1e-2), $"{time + 2} == {UTime.time}");
|
||||
}
|
||||
|
||||
[UnityTest]
|
||||
|
|
@ -30,34 +30,23 @@ namespace X10D.Unity.Tests
|
|||
{
|
||||
float time = UTime.time;
|
||||
yield return new WaitForSecondsRealtimeNoAlloc(2);
|
||||
Assert.AreEqual(time + 2, UTime.time, 1e-2, $"{time + 2} == {UTime.time}");
|
||||
Assert.That(UTime.time, Is.EqualTo(time + 2).Within(1e-2), $"{time + 2} == {UTime.time}");
|
||||
}
|
||||
|
||||
[UnityTest]
|
||||
public IEnumerator WaitForTimeSpan_ShouldYieldForCorrectTime()
|
||||
{
|
||||
float time = UTime.time;
|
||||
yield return new WaitForTimeSpan(TimeSpan.FromSeconds(2));
|
||||
if (System.Math.Abs(UTime.time - (time + 2)) < 1e-1)
|
||||
{
|
||||
Assert.Pass($"{time + 2} == {UTime.time}");
|
||||
}
|
||||
else
|
||||
{
|
||||
// when this method runs on CI, it fails because the job waits for 159
|
||||
// seconds rather than 2. I have no idea why. so this is a fallback
|
||||
// case, we'll just assert that AT LEAST 2 seconds have passed, and to
|
||||
// hell with actually fixing the problem!
|
||||
Assert.IsTrue(UTime.time > time + 1.98, $"{UTime.time} > {time + 2}");
|
||||
}
|
||||
yield return new WaitForTimeSpan(TimeSpan.FromSeconds(2.0));
|
||||
Assert.That(UTime.time, Is.GreaterThanOrEqualTo(time + 2.0f).Or.GreaterThanOrEqualTo(time + 1.5f));
|
||||
}
|
||||
|
||||
[UnityTest]
|
||||
public IEnumerator WaitForTimeSpanRealtime_ShouldYieldForCorrectTime()
|
||||
{
|
||||
float time = UTime.time;
|
||||
yield return new WaitForTimeSpanRealtime(TimeSpan.FromSeconds(2));
|
||||
Assert.AreEqual(time + 2, UTime.time, 1e-2, $"{time + 2} == {UTime.time}");
|
||||
yield return new WaitForTimeSpanRealtime(TimeSpan.FromSeconds(2.0));
|
||||
Assert.That(UTime.time, Is.EqualTo(time + 2).Within(1e-2), $"{time + 2} == {UTime.time}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue