tsai
/
ImageSharp
mirror of https://github.com/SixLabors/ImageSharp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #53 from olivif/olivif/colorconstructortests 

Adding unit tests for color constructors. Adding tests for packing. Improving equality tests.
pull/56/head
James Jackson-South 10 years ago
committed by GitHub
parent
1bfd6bd4cf 7f5139408c
commit
4f533666d0
4 changed files with 370 additions and 69 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 140
      tests/ImageSharp.Tests/Colors/ColorConstructorTests.cs
  2. 211
      tests/ImageSharp.Tests/Colors/ColorEqualityTests.cs
  3. 84
      tests/ImageSharp.Tests/Colors/ColorPackingTests.cs
  4. 4
      tests/ImageSharp.Tests/Colors/PackedPixelTests.cs

140
tests/ImageSharp.Tests/Colors/ColorConstructorTests.cs
View File

@ -0,0 +1,140 @@
// <copyright file="ColorConstructorTests.cs" company="James Jackson-South">
// Copyright (c) James Jackson-South and contributors.
// Licensed under the Apache License, Version 2.0.
// </copyright>
namespace ImageSharp.Tests.Colors
{
using System.Collections.Generic;
using System.Numerics;
using Xunit;
public class ColorConstructorTests
{
public static IEnumerable<object[]> Vector4Data
{
get
{
var vector4Values = new Vector4[]
{
Vector4.Zero,
Vector4.One,
Vector4.UnitX,
Vector4.UnitY,
Vector4.UnitZ,
Vector4.UnitW,
};
foreach (var vector4 in vector4Values)
{
yield return new object[] { new Argb(vector4), vector4 };
yield return new object[] { new Bgra4444(vector4), vector4 };
yield return new object[] { new Bgra5551(vector4), vector4 };
yield return new object[] { new Byte4(vector4), vector4 };
yield return new object[] { new HalfVector4(vector4), vector4 };
yield return new object[] { new NormalizedByte4(vector4), vector4 };
yield return new object[] { new NormalizedShort4(vector4), vector4 };
yield return new object[] { new Rgba1010102(vector4), vector4 };
yield return new object[] { new Rgba64(vector4), vector4 };
yield return new object[] { new Short4(vector4), vector4 };
}
}
}
public static IEnumerable<object[]> Vector3Data
{
get
{
var vector3Values = new Dictionary<Vector3, Vector4>()
{
{ Vector3.One, Vector4.One },
{ Vector3.Zero, new Vector4(0, 0, 0, 1) },
{ Vector3.UnitX, new Vector4(1, 0, 0, 1) },
{ Vector3.UnitY, new Vector4(0, 1, 0, 1) },
{ Vector3.UnitZ, new Vector4(0, 0, 1, 1) },
};
foreach (var vector3 in vector3Values.Keys)
{
var vector4 = vector3Values[vector3];
yield return new object[] { new Argb(vector3), vector4 };
yield return new object[] { new Bgr565(vector3), vector4 };
}
}
}
public static IEnumerable<object[]> Float4Data
{
get
{
var vector4Values = new Vector4[]
{
Vector4.Zero,
Vector4.One,
Vector4.UnitX,
Vector4.UnitY,
Vector4.UnitZ,
Vector4.UnitW,
};
foreach (var vector4 in vector4Values)
{
yield return new object[] { new Argb(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4 };
yield return new object[] { new Bgra4444(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4 };
yield return new object[] { new Bgra5551(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4 };
yield return new object[] { new Byte4(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4 };
yield return new object[] { new HalfVector4(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4 };
yield return new object[] { new NormalizedByte4(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4 };
yield return new object[] { new NormalizedShort4(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4 };
yield return new object[] { new Rgba1010102(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4 };
yield return new object[] { new Rgba64(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4 };
yield return new object[] { new Short4(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4 };
}
}
}
public static IEnumerable<object[]> Float3Data
{
get
{
var vector3Values = new Dictionary<Vector3, Vector4>()
{
{ Vector3.One, Vector4.One },
{ Vector3.Zero, new Vector4(0, 0, 0, 1) },
{ Vector3.UnitX, new Vector4(1, 0, 0, 1) },
{ Vector3.UnitY, new Vector4(0, 1, 0, 1) },
{ Vector3.UnitZ, new Vector4(0, 0, 1, 1) },
};
foreach (var vector3 in vector3Values.Keys)
{
var vector4 = vector3Values[vector3];
yield return new object[] { new Argb(vector3.X, vector3.Y, vector3.Z), vector4 };
yield return new object[] { new Bgr565(vector3.X, vector3.Y, vector3.Z), vector4 };
}
}
}
[Theory]
[MemberData(nameof(Vector4Data))]
[MemberData(nameof(Vector3Data))]
[MemberData(nameof(Float4Data))]
[MemberData(nameof(Float3Data))]
public void ConstructorToVector4(IPackedVector packedVector, Vector4 expectedVector4)
{
// Arrange
var precision = 2;
// Act
var vector4 = packedVector.ToVector4();
// Assert
Assert.Equal(expectedVector4.X, vector4.X, precision);
Assert.Equal(expectedVector4.Y, vector4.Y, precision);
Assert.Equal(expectedVector4.Z, vector4.Z, precision);
Assert.Equal(expectedVector4.W, vector4.W, precision);
}
}
}

211
tests/ImageSharp.Tests/Colors/ColorEqualityTests.cs
View File

@ -5,6 +5,7 @@
namespace ImageSharp.Tests.Colors
{
using System;
using System.Numerics;
using Xunit;
@ -13,89 +14,89 @@ namespace ImageSharp.Tests.Colors
/// </summary>
public class ColorEqualityTests
{
public static readonly TheoryData<object, object> EqualityData =
new TheoryData<object, object>()
public static readonly TheoryData<object, object, Type> EqualityData =
new TheoryData<object, object, Type>()
{
{ new Alpha8(.5F), new Alpha8(.5F) },
{ new Argb(Vector4.One), new Argb(Vector4.One) },
{ new Bgr565(Vector3.One), new Bgr565(Vector3.One) },
{ new Bgra4444(Vector4.One), new Bgra4444(Vector4.One) },
{ new Bgra5551(Vector4.One), new Bgra5551(Vector4.One) },
{ new Byte4(Vector4.One * 255), new Byte4(Vector4.One * 255) },
{ new HalfSingle(-1F), new HalfSingle(-1F) },
{ new HalfVector2(0.1f, -0.3f), new HalfVector2(0.1f, -0.3f) },
{ new HalfVector4(Vector4.One), new HalfVector4(Vector4.One) },
{ new NormalizedByte2(-Vector2.One), new NormalizedByte2(-Vector2.One) },
{ new NormalizedByte4(Vector4.One), new NormalizedByte4(Vector4.One) },
{ new NormalizedShort2(Vector2.One), new NormalizedShort2(Vector2.One) },
{ new NormalizedShort4(Vector4.One), new NormalizedShort4(Vector4.One) },
{ new Rg32(Vector2.One), new Rg32(Vector2.One) },
{ new Rgba1010102(Vector4.One), new Rgba1010102(Vector4.One) },
{ new Rgba64(Vector4.One), new Rgba64(Vector4.One) },
{ new Short2(Vector2.One * 0x7FFF), new Short2(Vector2.One * 0x7FFF) },
{ new Short4(Vector4.One * 0x7FFF), new Short4(Vector4.One * 0x7FFF) },
{ new Alpha8(.5F), new Alpha8(.5F), typeof(Alpha8) },
{ new Argb(Vector4.One), new Argb(Vector4.One), typeof(Argb) },
{ new Bgr565(Vector3.One), new Bgr565(Vector3.One), typeof(Bgr565) },
{ new Bgra4444(Vector4.One), new Bgra4444(Vector4.One), typeof(Bgra4444) },
{ new Bgra5551(Vector4.One), new Bgra5551(Vector4.One), typeof(Bgra5551) },
{ new Byte4(Vector4.One * 255), new Byte4(Vector4.One * 255), typeof(Byte4) },
{ new HalfSingle(-1F), new HalfSingle(-1F), typeof(HalfSingle) },
{ new HalfVector2(0.1f, -0.3f), new HalfVector2(0.1f, -0.3f), typeof(HalfVector2) },
{ new HalfVector4(Vector4.One), new HalfVector4(Vector4.One), typeof(HalfVector4) },
{ new NormalizedByte2(-Vector2.One), new NormalizedByte2(-Vector2.One), typeof(NormalizedByte2) },
{ new NormalizedByte4(Vector4.One), new NormalizedByte4(Vector4.One), typeof(NormalizedByte4) },
{ new NormalizedShort2(Vector2.One), new NormalizedShort2(Vector2.One), typeof(NormalizedShort2) },
{ new NormalizedShort4(Vector4.One), new NormalizedShort4(Vector4.One), typeof(NormalizedShort4) },
{ new Rg32(Vector2.One), new Rg32(Vector2.One), typeof(Rg32) },
{ new Rgba1010102(Vector4.One), new Rgba1010102(Vector4.One), typeof(Rgba1010102) },
{ new Rgba64(Vector4.One), new Rgba64(Vector4.One), typeof(Rgba64) },
{ new Short2(Vector2.One * 0x7FFF), new Short2(Vector2.One * 0x7FFF), typeof(Short2) },
{ new Short4(Vector4.One * 0x7FFF), new Short4(Vector4.One * 0x7FFF), typeof(Short4) },
};
public static readonly TheoryData<object, object> NotEqualityDataNulls =
new TheoryData<object, object>()
public static readonly TheoryData<object, object, Type> NotEqualityDataNulls =
new TheoryData<object, object, Type>()
{
// Valid object against null
{ new Alpha8(.5F), null },
{ new Argb(Vector4.One), null },
{ new Bgr565(Vector3.One), null },
{ new Bgra4444(Vector4.One), null },
{ new Bgra5551(Vector4.One), null },
{ new Byte4(Vector4.One * 255), null },
{ new HalfSingle(-1F), null },
{ new HalfVector2(0.1f, -0.3f), null },
{ new HalfVector4(Vector4.One), null },
{ new NormalizedByte2(-Vector2.One), null },
{ new NormalizedByte4(Vector4.One), null },
{ new NormalizedShort2(Vector2.One), null },
{ new NormalizedShort4(Vector4.One), null },
{ new Rg32(Vector2.One), null },
{ new Rgba1010102(Vector4.One), null },
{ new Rgba64(Vector4.One), null },
{ new Short2(Vector2.One * 0x7FFF), null },
{ new Short4(Vector4.One * 0x7FFF), null },
{ new Alpha8(.5F), null, typeof(Alpha8) },
{ new Argb(Vector4.One), null, typeof(Argb) },
{ new Bgr565(Vector3.One), null, typeof(Bgr565) },
{ new Bgra4444(Vector4.One), null, typeof(Bgra4444) },
{ new Bgra5551(Vector4.One), null, typeof(Bgra5551) },
{ new Byte4(Vector4.One * 255), null, typeof(Byte4) },
{ new HalfSingle(-1F), null, typeof(HalfSingle) },
{ new HalfVector2(0.1f, -0.3f), null, typeof(HalfVector2) },
{ new HalfVector4(Vector4.One), null, typeof(HalfVector4) },
{ new NormalizedByte2(-Vector2.One), null, typeof(NormalizedByte2) },
{ new NormalizedByte4(Vector4.One), null, typeof(NormalizedByte4) },
{ new NormalizedShort2(Vector2.One), null, typeof(NormalizedShort2) },
{ new NormalizedShort4(Vector4.One), null, typeof(NormalizedShort4) },
{ new Rg32(Vector2.One), null, typeof(Rg32) },
{ new Rgba1010102(Vector4.One), null, typeof(Rgba1010102) },
{ new Rgba64(Vector4.One), null, typeof(Rgba64) },
{ new Short2(Vector2.One * 0x7FFF), null, typeof(Short2) },
{ new Short4(Vector4.One * 0x7FFF), null, typeof(Short4) },
};
public static readonly TheoryData<object, object> NotEqualityDataDifferentObjects =
new TheoryData<object, object>()
public static readonly TheoryData<object, object, Type> NotEqualityDataDifferentObjects =
new TheoryData<object, object, Type>()
{
// Valid objects of different types but not equal
{ new Alpha8(.5F), new Argb(Vector4.Zero) },
{ new HalfSingle(-1F), new NormalizedShort2(Vector2.Zero) },
{ new Rgba1010102(Vector4.One), new Bgra5551(Vector4.Zero) },
{ new Alpha8(.5F), new Argb(Vector4.Zero), null },
{ new HalfSingle(-1F), new NormalizedShort2(Vector2.Zero), null },
{ new Rgba1010102(Vector4.One), new Bgra5551(Vector4.Zero), null },
};
public static readonly TheoryData<object, object> NotEqualityData =
new TheoryData<object, object>()
public static readonly TheoryData<object, object, Type> NotEqualityData =
new TheoryData<object, object, Type>()
{
// Valid objects of the same type but not equal
{ new Alpha8(.5F), new Alpha8(.8F) },
{ new Argb(Vector4.One), new Argb(Vector4.Zero) },
{ new Bgr565(Vector3.One), new Bgr565(Vector3.Zero) },
{ new Bgra4444(Vector4.One), new Bgra4444(Vector4.Zero) },
{ new Bgra5551(Vector4.One), new Bgra5551(Vector4.Zero) },
{ new Byte4(Vector4.One * 255), new Byte4(Vector4.Zero) },
{ new HalfSingle(-1F), new HalfSingle(1F) },
{ new HalfVector2(0.1f, -0.3f), new HalfVector2(0.1f, 0.3f) },
{ new HalfVector4(Vector4.One), new HalfVector4(Vector4.Zero) },
{ new NormalizedByte2(-Vector2.One), new NormalizedByte2(-Vector2.Zero) },
{ new NormalizedByte4(Vector4.One), new NormalizedByte4(Vector4.Zero) },
{ new NormalizedShort2(Vector2.One), new NormalizedShort2(Vector2.Zero) },
{ new NormalizedShort4(Vector4.One), new NormalizedShort4(Vector4.Zero) },
{ new Rg32(Vector2.One), new Rg32(Vector2.Zero) },
{ new Rgba1010102(Vector4.One), new Rgba1010102(Vector4.Zero) },
{ new Rgba64(Vector4.One), new Rgba64(Vector4.Zero) },
{ new Short2(Vector2.One * 0x7FFF), new Short2(Vector2.Zero) },
{ new Short4(Vector4.One * 0x7FFF), new Short4(Vector4.Zero) },
{ new Alpha8(.5F), new Alpha8(.8F), typeof(Alpha8) },
{ new Argb(Vector4.One), new Argb(Vector4.Zero), typeof(Argb) },
{ new Bgr565(Vector3.One), new Bgr565(Vector3.Zero), typeof(Bgr565) },
{ new Bgra4444(Vector4.One), new Bgra4444(Vector4.Zero), typeof(Bgra4444) },
{ new Bgra5551(Vector4.One), new Bgra5551(Vector4.Zero), typeof(Bgra5551) },
{ new Byte4(Vector4.One * 255), new Byte4(Vector4.Zero), typeof(Byte4) },
{ new HalfSingle(-1F), new HalfSingle(1F), typeof(HalfSingle) },
{ new HalfVector2(0.1f, -0.3f), new HalfVector2(0.1f, 0.3f), typeof(HalfVector2) },
{ new HalfVector4(Vector4.One), new HalfVector4(Vector4.Zero), typeof(HalfVector4) },
{ new NormalizedByte2(-Vector2.One), new NormalizedByte2(-Vector2.Zero), typeof(NormalizedByte2) },
{ new NormalizedByte4(Vector4.One), new NormalizedByte4(Vector4.Zero), typeof(NormalizedByte4) },
{ new NormalizedShort2(Vector2.One), new NormalizedShort2(Vector2.Zero), typeof(NormalizedShort2) },
{ new NormalizedShort4(Vector4.One), new NormalizedShort4(Vector4.Zero), typeof(NormalizedShort4) },
{ new Rg32(Vector2.One), new Rg32(Vector2.Zero), typeof(Rg32) },
{ new Rgba1010102(Vector4.One), new Rgba1010102(Vector4.Zero), typeof(Rgba1010102) },
{ new Rgba64(Vector4.One), new Rgba64(Vector4.Zero), typeof(Rgba64) },
{ new Short2(Vector2.One * 0x7FFF), new Short2(Vector2.Zero), typeof(Short2) },
{ new Short4(Vector4.One * 0x7FFF), new Short4(Vector4.Zero), typeof(Short4) },
};
[Theory]
[MemberData(nameof(EqualityData))]
public void Equality(object first, object second)
public void Equality(object first, object second, Type type)
{
// Act
var equal = first.Equals(second);
@ -108,7 +109,7 @@ namespace ImageSharp.Tests.Colors
[MemberData(nameof(NotEqualityDataNulls))]
[MemberData(nameof(NotEqualityDataDifferentObjects))]
[MemberData(nameof(NotEqualityData))]
public void NotEquality(object first, object second)
public void NotEquality(object first, object second, Type type)
{
// Act
var equal = first.Equals(second);
@ -119,7 +120,7 @@ namespace ImageSharp.Tests.Colors
[Theory]
[MemberData(nameof(EqualityData))]
public void HashCodeEqual(object first, object second)
public void HashCodeEqual(object first, object second, Type type)
{
// Act
var equal = first.GetHashCode() == second.GetHashCode();
@ -130,7 +131,7 @@ namespace ImageSharp.Tests.Colors
[Theory]
[MemberData(nameof(NotEqualityDataDifferentObjects))]
public void HashCodeNotEqual(object first, object second)
public void HashCodeNotEqual(object first, object second, Type type)
{
// Act
var equal = first.GetHashCode() == second.GetHashCode();
@ -138,5 +139,77 @@ namespace ImageSharp.Tests.Colors
// Assert
Assert.False(equal);
}
[Theory]
[MemberData(nameof(EqualityData))]
public void EqualityObject(object first, object second, Type type)
{
// Arrange
// Cast to the known object types, this is so that we can hit the
// equality operator on the concrete type, otherwise it goes to the
// default "object" one :)
dynamic firstObject = Convert.ChangeType(first, type);
dynamic secondObject = Convert.ChangeType(second, type);
// Act
var equal = firstObject.Equals(secondObject);
// Assert
Assert.True(equal);
}
[Theory]
[MemberData(nameof(NotEqualityData))]
public void NotEqualityObject(object first, object second, Type type)
{
// Arrange
// Cast to the known object types, this is so that we can hit the
// equality operator on the concrete type, otherwise it goes to the
// default "object" one :)
dynamic firstObject = Convert.ChangeType(first, type);
dynamic secondObject = Convert.ChangeType(second, type);
// Act
var equal = firstObject.Equals(secondObject);
// Assert
Assert.False(equal);
}
[Theory]
[MemberData(nameof(EqualityData))]
public void EqualityOperator(object first, object second, Type type)
{
// Arrange
// Cast to the known object types, this is so that we can hit the
// equality operator on the concrete type, otherwise it goes to the
// default "object" one :)
dynamic firstObject = Convert.ChangeType(first, type);
dynamic secondObject = Convert.ChangeType(second, type);
// Act
var equal = firstObject == secondObject;
// Assert
Assert.True(equal);
}
[Theory]
[MemberData(nameof(NotEqualityData))]
public void NotEqualityOperator(object first, object second, Type type)
{
// Arrange
// Cast to the known object types, this is so that we can hit the
// equality operator on the concrete type, otherwise it goes to the
// default "object" one :)
dynamic firstObject = Convert.ChangeType(first, type);
dynamic secondObject = Convert.ChangeType(second, type);
// Act
var notEqual = firstObject != secondObject;
// Assert
Assert.True(notEqual);
}
}
}

84
tests/ImageSharp.Tests/Colors/ColorPackingTests.cs
View File

@ -0,0 +1,84 @@
// <copyright file="ColorPackingTests.cs" company="James Jackson-South">
// Copyright (c) James Jackson-South and contributors.
// Licensed under the Apache License, Version 2.0.
// </copyright>
namespace ImageSharp.Tests.Colors
{
using System.Collections.Generic;
using System.Numerics;
using Xunit;
public class ColorPackingTests
{
public static IEnumerable<object[]> Vector4PackData
{
get
{
var vector4Values = new Vector4[]
{
Vector4.Zero,
Vector4.One,
Vector4.UnitX,
Vector4.UnitY,
Vector4.UnitZ,
Vector4.UnitW,
};
foreach (var vector4 in vector4Values)
{
yield return new object[] { new Argb(), vector4 };
yield return new object[] { new Bgra4444(), vector4 };
yield return new object[] { new Bgra5551(), vector4 };
yield return new object[] { new Byte4(), vector4 };
yield return new object[] { new HalfVector4(), vector4 };
yield return new object[] { new NormalizedByte4(), vector4 };
yield return new object[] { new NormalizedShort4(), vector4 };
yield return new object[] { new Rgba1010102(), vector4 };
yield return new object[] { new Rgba64(), vector4 };
yield return new object[] { new Short4(), vector4 };
}
}
}
public static IEnumerable<object[]> Vector3PackData
{
get
{
var vector4Values = new Vector4[]
{
Vector4.One,
new Vector4(0, 0, 0, 1),
new Vector4(1, 0, 0, 1),
new Vector4(0, 1, 0, 1),
new Vector4(0, 0, 1, 1),
};
foreach (var vector4 in vector4Values)
{
yield return new object[] { new Argb(), vector4 };
yield return new object[] { new Bgr565(), vector4 };
}
}
}
[Theory]
[MemberData(nameof(Vector4PackData))]
[MemberData(nameof(Vector3PackData))]
public void FromVector4ToVector4(IPackedVector packedVector, Vector4 vector4ToPack)
{
// Arrange
var precision = 2;
packedVector.PackFromVector4(vector4ToPack);
// Act
var vector4 = packedVector.ToVector4();
// Assert
Assert.Equal(vector4ToPack.X, vector4.X, precision);
Assert.Equal(vector4ToPack.Y, vector4.Y, precision);
Assert.Equal(vector4ToPack.Z, vector4.Z, precision);
Assert.Equal(vector4ToPack.W, vector4.W, precision);
}
}
}

4
tests/ImageSharp.Tests/Colors/PackedPixelTests.cs
View File

@ -13,6 +13,10 @@ namespace ImageSharp.Tests.Colors
/// <summary>
/// The packed pixel tests.
/// </summary>
/// <remarks>
/// The "ToVector4" tests should now be covered in <see cref="ColorConstructorTests"/>
/// and at some point they can be safely removed from here.
/// </remarks>
public class PackedPixelTests
{
[Fact]

Write Preview
Loading…
Cancel
Save