mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
8 years ago
83 changed files with 5479 additions and 9355 deletions
@ -1,151 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Collections.Generic; |
|||
using System.Numerics; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests.Colors |
|||
{ |
|||
public class ColorConstructorTests |
|||
{ |
|||
public static IEnumerable<object[]> Vector4Data |
|||
{ |
|||
get |
|||
{ |
|||
Vector4[] vector4Values = new Vector4[] |
|||
{ |
|||
Vector4.Zero, |
|||
Vector4.One, |
|||
Vector4.UnitX, |
|||
Vector4.UnitY, |
|||
Vector4.UnitZ, |
|||
Vector4.UnitW, |
|||
}; |
|||
|
|||
foreach (Vector4 vector4 in vector4Values) |
|||
{ |
|||
// using float array to work around a bug in xunit corruptint the state of any Vector4 passed as MemberData
|
|||
float[] vector4Components = new float[] { vector4.X, vector4.Y, vector4.Z, vector4.W }; |
|||
|
|||
yield return new object[] { new Argb32(vector4), vector4Components }; |
|||
yield return new object[] { new Bgra4444(vector4), vector4Components }; |
|||
yield return new object[] { new Bgra5551(vector4), vector4Components }; |
|||
yield return new object[] { new Byte4(vector4), vector4Components }; |
|||
yield return new object[] { new HalfVector4(vector4), vector4Components }; |
|||
yield return new object[] { new NormalizedByte4(vector4), vector4Components }; |
|||
yield return new object[] { new NormalizedShort4(vector4), vector4Components }; |
|||
yield return new object[] { new Rgba1010102(vector4), vector4Components }; |
|||
yield return new object[] { new Rgba64(vector4), vector4Components }; |
|||
yield return new object[] { new Short4(vector4), vector4Components }; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public static IEnumerable<object[]> Vector3Data |
|||
{ |
|||
get |
|||
{ |
|||
Dictionary<Vector3, Vector4> 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 (Vector3 vector3 in vector3Values.Keys) |
|||
{ |
|||
Vector4 vector4 = vector3Values[vector3]; |
|||
// using float array to work around a bug in xunit corruptint the state of any Vector4 passed as MemberData
|
|||
float[] vector4Components = new float[] { vector4.X, vector4.Y, vector4.Z, vector4.W }; |
|||
|
|||
yield return new object[] { new Argb32(vector3), vector4Components }; |
|||
yield return new object[] { new Bgr565(vector3), vector4Components }; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public static IEnumerable<object[]> Float4Data |
|||
{ |
|||
get |
|||
{ |
|||
Vector4[] vector4Values = new Vector4[] |
|||
{ |
|||
Vector4.Zero, |
|||
Vector4.One, |
|||
Vector4.UnitX, |
|||
Vector4.UnitY, |
|||
Vector4.UnitZ, |
|||
Vector4.UnitW, |
|||
}; |
|||
|
|||
foreach (Vector4 vector4 in vector4Values) |
|||
{ |
|||
// using float array to work around a bug in xunit corruptint the state of any Vector4 passed as MemberData
|
|||
float[] vector4Components = new float[] { vector4.X, vector4.Y, vector4.Z, vector4.W }; |
|||
|
|||
yield return new object[] { new Argb32(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4Components }; |
|||
yield return new object[] { new Bgra4444(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4Components }; |
|||
yield return new object[] { new Bgra5551(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4Components }; |
|||
yield return new object[] { new Byte4(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4Components }; |
|||
yield return new object[] { new HalfVector4(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4Components }; |
|||
yield return new object[] { new NormalizedByte4(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4Components }; |
|||
yield return new object[] { new NormalizedShort4(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4Components }; |
|||
yield return new object[] { new Rgba1010102(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4Components }; |
|||
yield return new object[] { new Rgba64(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4Components }; |
|||
yield return new object[] { new Short4(vector4.X, vector4.Y, vector4.Z, vector4.W), vector4Components }; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public static IEnumerable<object[]> Float3Data |
|||
{ |
|||
get |
|||
{ |
|||
Dictionary<Vector3, Vector4> 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 (Vector3 vector3 in vector3Values.Keys) |
|||
{ |
|||
Vector4 vector4 = vector3Values[vector3]; |
|||
// using float array to work around a bug in xunit corruptint the state of any Vector4 passed as MemberData
|
|||
float[] vector4Components = new float[] { vector4.X, vector4.Y, vector4.Z, vector4.W }; |
|||
|
|||
yield return new object[] { new Argb32(vector3.X, vector3.Y, vector3.Z), vector4Components }; |
|||
yield return new object[] { new Bgr565(vector3.X, vector3.Y, vector3.Z), vector4Components }; |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(Vector4Data))] |
|||
[MemberData(nameof(Vector3Data))] |
|||
[MemberData(nameof(Float4Data))] |
|||
[MemberData(nameof(Float3Data))] |
|||
public void ConstructorToVector4(IPixel packedVector, float[] expectedVector4Components) |
|||
{ |
|||
// Arrange
|
|||
int precision = 2; |
|||
// using float array to work around a bug in xunit corruptint the state of any Vector4 passed as MemberData
|
|||
Vector4 expectedVector4 = new Vector4(expectedVector4Components[0], expectedVector4Components[1], expectedVector4Components[2], expectedVector4Components[3]); |
|||
|
|||
// Act
|
|||
Vector4 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); |
|||
} |
|||
} |
|||
} |
|||
@ -1,216 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests.Colors |
|||
{ |
|||
/// <summary>
|
|||
/// Test implementations of IEquatable
|
|||
/// </summary>
|
|||
public class ColorEqualityTests |
|||
{ |
|||
public static readonly TheoryData<object, object, Type> EqualityData = |
|||
new TheoryData<object, object, Type>() |
|||
{ |
|||
{ new Alpha8(.5F), new Alpha8(.5F), typeof(Alpha8) }, |
|||
{ new Argb32(Vector4.One), new Argb32(Vector4.One), typeof(Argb32) }, |
|||
{ 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 Rgba32(Vector4.One), new Rgba32(Vector4.One), typeof(Rgba32) }, |
|||
{ 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, Type> NotEqualityDataNulls = |
|||
new TheoryData<object, object, Type>() |
|||
{ |
|||
// Valid object against null
|
|||
{ new Alpha8(.5F), null, typeof(Alpha8) }, |
|||
{ new Argb32(Vector4.One), null, typeof(Argb32) }, |
|||
{ 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, Type> NotEqualityDataDifferentObjects = |
|||
new TheoryData<object, object, Type>() |
|||
{ |
|||
// Valid objects of different types but not equal
|
|||
{ new Alpha8(.5F), new Argb32(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, Type> NotEqualityData = |
|||
new TheoryData<object, object, Type>() |
|||
{ |
|||
// Valid objects of the same type but not equal
|
|||
{ new Alpha8(.5F), new Alpha8(.8F), typeof(Alpha8) }, |
|||
{ new Argb32(Vector4.One), new Argb32(Vector4.Zero), typeof(Argb32) }, |
|||
{ 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 Rgba32(Vector4.One), new Rgba32(Vector4.Zero), typeof(Rgba32) }, |
|||
{ 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, Type type) |
|||
{ |
|||
// Act
|
|||
bool equal = first.Equals(second); |
|||
|
|||
// Assert
|
|||
Assert.True(equal); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(NotEqualityDataNulls))] |
|||
[MemberData(nameof(NotEqualityDataDifferentObjects))] |
|||
[MemberData(nameof(NotEqualityData))] |
|||
public void NotEquality(object first, object second, Type type) |
|||
{ |
|||
// Act
|
|||
bool equal = first.Equals(second); |
|||
|
|||
// Assert
|
|||
Assert.False(equal); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(EqualityData))] |
|||
public void HashCodeEqual(object first, object second, Type type) |
|||
{ |
|||
// Act
|
|||
bool equal = first.GetHashCode() == second.GetHashCode(); |
|||
|
|||
// Assert
|
|||
Assert.True(equal); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(NotEqualityDataDifferentObjects))] |
|||
public void HashCodeNotEqual(object first, object second, Type type) |
|||
{ |
|||
// Act
|
|||
bool equal = first.GetHashCode() == second.GetHashCode(); |
|||
|
|||
// 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
|
|||
dynamic 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
|
|||
dynamic 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
|
|||
dynamic 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
|
|||
dynamic notEqual = firstObject != secondObject; |
|||
|
|||
// Assert
|
|||
Assert.True(notEqual); |
|||
} |
|||
} |
|||
} |
|||
@ -1,88 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Collections.Generic; |
|||
using System.Numerics; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests.Colors |
|||
{ |
|||
public class ColorPackingTests |
|||
{ |
|||
public static IEnumerable<object[]> Vector4PackData |
|||
{ |
|||
get |
|||
{ |
|||
Vector4[] vector4Values = new Vector4[] |
|||
{ |
|||
Vector4.Zero, |
|||
Vector4.One, |
|||
Vector4.UnitX, |
|||
Vector4.UnitY, |
|||
Vector4.UnitZ, |
|||
Vector4.UnitW, |
|||
}; |
|||
|
|||
foreach (Vector4 vector4 in vector4Values) |
|||
{ |
|||
float[] vector4Components = new float[] { vector4.X, vector4.Y, vector4.Z, vector4.W }; |
|||
|
|||
yield return new object[] { default(Argb32), vector4Components }; |
|||
yield return new object[] { default(Bgra4444), vector4Components }; |
|||
yield return new object[] { default(Bgra5551), vector4Components }; |
|||
yield return new object[] { default(Byte4), vector4Components }; |
|||
yield return new object[] { default(HalfVector4), vector4Components }; |
|||
yield return new object[] { default(NormalizedByte4), vector4Components }; |
|||
yield return new object[] { default(NormalizedShort4), vector4Components }; |
|||
yield return new object[] { default(Rgba1010102), vector4Components }; |
|||
yield return new object[] { default(Rgba64), vector4Components }; |
|||
yield return new object[] { default(Short4), vector4Components }; |
|||
} |
|||
} |
|||
} |
|||
|
|||
public static IEnumerable<object[]> Vector3PackData |
|||
{ |
|||
get |
|||
{ |
|||
Vector4[] 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 (Vector4 vector4 in vector4Values) |
|||
{ |
|||
float[] vector4Components = new float[] { vector4.X, vector4.Y, vector4.Z, vector4.W }; |
|||
|
|||
yield return new object[] { default(Argb32), vector4Components }; |
|||
yield return new object[] { new Bgr565(), vector4Components }; |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(Vector4PackData))] |
|||
[MemberData(nameof(Vector3PackData))] |
|||
public void FromVector4ToVector4(IPixel packedVector, float[] vector4ComponentsToPack) |
|||
{ |
|||
// Arrange
|
|||
int precision = 2; |
|||
Vector4 vector4ToPack = new Vector4(vector4ComponentsToPack[0], vector4ComponentsToPack[1], vector4ComponentsToPack[2], vector4ComponentsToPack[3]); |
|||
packedVector.PackFromVector4(vector4ToPack); |
|||
|
|||
// Act
|
|||
Vector4 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); |
|||
} |
|||
} |
|||
} |
|||
File diff suppressed because it is too large
@ -1,175 +1,175 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests.PixelFormats |
|||
{ |
|||
public class Rgb24Tests |
|||
{ |
|||
public static readonly TheoryData<byte, byte, byte> ColorData = |
|||
new TheoryData<byte, byte, byte>() { { 1, 2, 3 }, { 4, 5, 6 }, { 0, 255, 42 } }; |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(ColorData))] |
|||
public void Constructor(byte r, byte g, byte b) |
|||
{ |
|||
var p = new Rgb24(r, g, b); |
|||
|
|||
Assert.Equal(r, p.R); |
|||
Assert.Equal(g, p.G); |
|||
Assert.Equal(b, p.B); |
|||
} |
|||
|
|||
[Fact] |
|||
public unsafe void ByteLayoutIsSequentialRgb() |
|||
{ |
|||
var color = new Rgb24(1, 2, 3); |
|||
byte* ptr = (byte*)&color; |
|||
|
|||
Assert.Equal(1, ptr[0]); |
|||
Assert.Equal(2, ptr[1]); |
|||
Assert.Equal(3, ptr[2]); |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(ColorData))] |
|||
public void Equals_WhenTrue(byte r, byte g, byte b) |
|||
{ |
|||
var x = new Rgb24(r, g, b); |
|||
var y = new Rgb24(r, g, b); |
|||
|
|||
Assert.True(x.Equals(y)); |
|||
Assert.True(x.Equals((object)y)); |
|||
Assert.Equal(x.GetHashCode(), y.GetHashCode()); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(1, 2, 3, 1, 2, 4)] |
|||
[InlineData(0, 255, 0, 0, 244, 0)] |
|||
[InlineData(1, 255, 0, 0, 255, 0)] |
|||
public void Equals_WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2) |
|||
{ |
|||
var a = new Rgb24(r1, g1, b1); |
|||
var b = new Rgb24(r2, g2, b2); |
|||
|
|||
Assert.False(a.Equals(b)); |
|||
Assert.False(a.Equals((object)b)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void PackFromRgba32() |
|||
{ |
|||
var rgb = default(Rgb24); |
|||
rgb.PackFromRgba32(new Rgba32(1, 2, 3, 4)); |
|||
|
|||
Assert.Equal(1, rgb.R); |
|||
Assert.Equal(2, rgb.G); |
|||
Assert.Equal(3, rgb.B); |
|||
} |
|||
|
|||
private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4( |
|||
r / 255f, |
|||
g / 255f, |
|||
b / 255f, |
|||
a / 255f); |
|||
|
|||
[Fact] |
|||
public void PackFromVector4() |
|||
{ |
|||
var rgb = default(Rgb24); |
|||
rgb.PackFromVector4(Vec(1, 2, 3, 4)); |
|||
|
|||
Assert.Equal(1, rgb.R); |
|||
Assert.Equal(2, rgb.G); |
|||
Assert.Equal(3, rgb.B); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ToVector4() |
|||
{ |
|||
var rgb = new Rgb24(1, 2, 3); |
|||
|
|||
Assert.Equal(Vec(1, 2, 3), rgb.ToVector4()); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ToRgb24() |
|||
{ |
|||
var rgb = new Rgb24(1, 2, 3); |
|||
var dest = default(Rgb24); |
|||
|
|||
rgb.ToRgb24(ref dest); |
|||
|
|||
Assert.Equal(rgb, dest); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ToRgba32() |
|||
{ |
|||
var rgb = new Rgb24(1, 2, 3); |
|||
var rgba = default(Rgba32); |
|||
|
|||
rgb.ToRgba32(ref rgba); |
|||
|
|||
Assert.Equal(new Rgba32(1, 2, 3, 255), rgba); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ToBgr24() |
|||
{ |
|||
var rgb = new Rgb24(1, 2, 3); |
|||
var bgr = default(Bgr24); |
|||
|
|||
rgb.ToBgr24(ref bgr); |
|||
|
|||
Assert.Equal(new Bgr24(1, 2, 3), bgr); |
|||
} |
|||
|
|||
[Fact] |
|||
public void ToBgra32() |
|||
{ |
|||
var rgb = new Rgb24(1, 2, 3); |
|||
var bgra = default(Bgra32); |
|||
|
|||
rgb.ToBgra32(ref bgra); |
|||
|
|||
Assert.Equal(new Bgra32(1, 2, 3, 255), bgra); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb24_PackFromRgb48_ToRgb48() |
|||
{ |
|||
// arrange
|
|||
var input = default(Rgb24); |
|||
var actual = default(Rgb48); |
|||
var expected = new Rgb48(65535, 0, 65535); |
|||
|
|||
// act
|
|||
input.PackFromRgb48(expected); |
|||
input.ToRgb48(ref actual); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, actual); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb24_PackFromRgba64_ToRgba64() |
|||
{ |
|||
// arrange
|
|||
var input = default(Rgb24); |
|||
var actual = default(Rgba64); |
|||
var expected = new Rgba64(65535, 0, 65535, 65535); |
|||
|
|||
// act
|
|||
input.PackFromRgba64(expected); |
|||
input.ToRgba64(ref actual); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, actual); |
|||
} |
|||
} |
|||
} |
|||
//// Copyright (c) Six Labors and contributors.
|
|||
//// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
//using System;
|
|||
//using System.Numerics;
|
|||
//using SixLabors.ImageSharp.PixelFormats;
|
|||
//using Xunit;
|
|||
|
|||
//namespace SixLabors.ImageSharp.Tests.PixelFormats
|
|||
//{
|
|||
// public class Rgb24Tests
|
|||
// {
|
|||
// public static readonly TheoryData<byte, byte, byte> ColorData =
|
|||
// new TheoryData<byte, byte, byte>() { { 1, 2, 3 }, { 4, 5, 6 }, { 0, 255, 42 } };
|
|||
|
|||
// [Theory]
|
|||
// [MemberData(nameof(ColorData))]
|
|||
// public void Constructor(byte r, byte g, byte b)
|
|||
// {
|
|||
// var p = new Rgb24(r, g, b);
|
|||
|
|||
// Assert.Equal(r, p.R);
|
|||
// Assert.Equal(g, p.G);
|
|||
// Assert.Equal(b, p.B);
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public unsafe void ByteLayoutIsSequentialRgb()
|
|||
// {
|
|||
// var color = new Rgb24(1, 2, 3);
|
|||
// byte* ptr = (byte*)&color;
|
|||
|
|||
// Assert.Equal(1, ptr[0]);
|
|||
// Assert.Equal(2, ptr[1]);
|
|||
// Assert.Equal(3, ptr[2]);
|
|||
// }
|
|||
|
|||
// [Theory]
|
|||
// [MemberData(nameof(ColorData))]
|
|||
// public void Equals_WhenTrue(byte r, byte g, byte b)
|
|||
// {
|
|||
// var x = new Rgb24(r, g, b);
|
|||
// var y = new Rgb24(r, g, b);
|
|||
|
|||
// Assert.True(x.Equals(y));
|
|||
// Assert.True(x.Equals((object)y));
|
|||
// Assert.Equal(x.GetHashCode(), y.GetHashCode());
|
|||
// }
|
|||
|
|||
// [Theory]
|
|||
// [InlineData(1, 2, 3, 1, 2, 4)]
|
|||
// [InlineData(0, 255, 0, 0, 244, 0)]
|
|||
// [InlineData(1, 255, 0, 0, 255, 0)]
|
|||
// public void Equals_WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
|
|||
// {
|
|||
// var a = new Rgb24(r1, g1, b1);
|
|||
// var b = new Rgb24(r2, g2, b2);
|
|||
|
|||
// Assert.False(a.Equals(b));
|
|||
// Assert.False(a.Equals((object)b));
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void PackFromRgba32()
|
|||
// {
|
|||
// var rgb = default(Rgb24);
|
|||
// rgb.PackFromRgba32(new Rgba32(1, 2, 3, 4));
|
|||
|
|||
// Assert.Equal(1, rgb.R);
|
|||
// Assert.Equal(2, rgb.G);
|
|||
// Assert.Equal(3, rgb.B);
|
|||
// }
|
|||
|
|||
// private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
|
|||
// r / 255f,
|
|||
// g / 255f,
|
|||
// b / 255f,
|
|||
// a / 255f);
|
|||
|
|||
// [Fact]
|
|||
// public void PackFromVector4()
|
|||
// {
|
|||
// var rgb = default(Rgb24);
|
|||
// rgb.PackFromVector4(Vec(1, 2, 3, 4));
|
|||
|
|||
// Assert.Equal(1, rgb.R);
|
|||
// Assert.Equal(2, rgb.G);
|
|||
// Assert.Equal(3, rgb.B);
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void ToVector4()
|
|||
// {
|
|||
// var rgb = new Rgb24(1, 2, 3);
|
|||
|
|||
// Assert.Equal(Vec(1, 2, 3), rgb.ToVector4());
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void ToRgb24()
|
|||
// {
|
|||
// var rgb = new Rgb24(1, 2, 3);
|
|||
// var dest = default(Rgb24);
|
|||
|
|||
// rgb.ToRgb24(ref dest);
|
|||
|
|||
// Assert.Equal(rgb, dest);
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void ToRgba32()
|
|||
// {
|
|||
// var rgb = new Rgb24(1, 2, 3);
|
|||
// var rgba = default(Rgba32);
|
|||
|
|||
// rgb.ToRgba32(ref rgba);
|
|||
|
|||
// Assert.Equal(new Rgba32(1, 2, 3, 255), rgba);
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void ToBgr24()
|
|||
// {
|
|||
// var rgb = new Rgb24(1, 2, 3);
|
|||
// var bgr = default(Bgr24);
|
|||
|
|||
// rgb.ToBgr24(ref bgr);
|
|||
|
|||
// Assert.Equal(new Bgr24(1, 2, 3), bgr);
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void ToBgra32()
|
|||
// {
|
|||
// var rgb = new Rgb24(1, 2, 3);
|
|||
// var bgra = default(Bgra32);
|
|||
|
|||
// rgb.ToBgra32(ref bgra);
|
|||
|
|||
// Assert.Equal(new Bgra32(1, 2, 3, 255), bgra);
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void Rgb24_PackFromRgb48_ToRgb48()
|
|||
// {
|
|||
// // arrange
|
|||
// var input = default(Rgb24);
|
|||
// var actual = default(Rgb48);
|
|||
// var expected = new Rgb48(65535, 0, 65535);
|
|||
|
|||
// // act
|
|||
// input.PackFromRgb48(expected);
|
|||
// input.ToRgb48(ref actual);
|
|||
|
|||
// // assert
|
|||
// Assert.Equal(expected, actual);
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void Rgb24_PackFromRgba64_ToRgba64()
|
|||
// {
|
|||
// // arrange
|
|||
// var input = default(Rgb24);
|
|||
// var actual = default(Rgba64);
|
|||
// var expected = new Rgba64(65535, 0, 65535, 65535);
|
|||
|
|||
// // act
|
|||
// input.PackFromRgba64(expected);
|
|||
// input.ToRgba64(ref actual);
|
|||
|
|||
// // assert
|
|||
// Assert.Equal(expected, actual);
|
|||
// }
|
|||
// }
|
|||
//}
|
|||
@ -1,199 +1,192 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System.Numerics; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests.PixelFormats |
|||
{ |
|||
public class Rgb48Tests |
|||
{ |
|||
[Fact] |
|||
public void Rgb48_Values() |
|||
{ |
|||
var rgb = new Rgba64(5243, 9830, 19660, 29491); |
|||
|
|||
Assert.Equal(5243, rgb.R); |
|||
Assert.Equal(9830, rgb.G); |
|||
Assert.Equal(19660, rgb.B); |
|||
Assert.Equal(29491, rgb.A); |
|||
|
|||
rgb = new Rgba64(5243 / 65535F, 9830 / 65535F, 19660 / 65535F, 29491 / 65535F); |
|||
|
|||
Assert.Equal(5243, rgb.R); |
|||
Assert.Equal(9830, rgb.G); |
|||
Assert.Equal(19660, rgb.B); |
|||
Assert.Equal(29491, rgb.A); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_ToVector4() |
|||
{ |
|||
Assert.Equal(new Vector4(0, 0, 0, 1), new Rgb48(Vector3.Zero).ToVector4()); |
|||
Assert.Equal(Vector4.One, new Rgb48(Vector3.One).ToVector4()); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_ToScaledVector4() |
|||
{ |
|||
// arrange
|
|||
var short2 = new Rgb48(Vector3.One); |
|||
|
|||
// act
|
|||
Vector4 actual = short2.ToScaledVector4(); |
|||
|
|||
// assert
|
|||
Assert.Equal(1, actual.X); |
|||
Assert.Equal(1, actual.Y); |
|||
Assert.Equal(1, actual.Z); |
|||
Assert.Equal(1, actual.W); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_PackFromScaledVector4() |
|||
{ |
|||
// arrange
|
|||
var pixel = default(Rgb48); |
|||
var short3 = new Rgb48(Vector3.One); |
|||
var expected = new Rgb48(Vector3.One); |
|||
|
|||
// act
|
|||
Vector4 scaled = short3.ToScaledVector4(); |
|||
pixel.PackFromScaledVector4(scaled); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, pixel); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_Clamping() |
|||
{ |
|||
Assert.Equal(new Vector4(0, 0, 0, 1), new Rgb48(Vector3.One * -1234.0f).ToVector4()); |
|||
Assert.Equal(Vector4.One, new Rgb48(Vector3.One * 1234.0f).ToVector4()); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_ToRgb24() |
|||
{ |
|||
// arrange
|
|||
var rgba48 = new Rgb48(0.08f, 0.15f, 0.30f); |
|||
var actual = default(Rgb24); |
|||
var expected = new Rgb24(20, 38, 76); |
|||
|
|||
// act
|
|||
rgba48.ToRgb24(ref actual); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, actual); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_ToRgba32() |
|||
{ |
|||
// arrange
|
|||
var rgba48 = new Rgb48(0.08f, 0.15f, 0.30f); |
|||
var actual = default(Rgba32); |
|||
var expected = new Rgba32(20, 38, 76, 255); |
|||
|
|||
// act
|
|||
rgba48.ToRgba32(ref actual); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, actual); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_ToArgb32() |
|||
{ |
|||
// arrange
|
|||
var rgba48 = new Rgb48(0.08f, 0.15f, 0.30f); |
|||
var actual = default(Argb32); |
|||
var expected = new Argb32(20, 38, 76, 255); |
|||
|
|||
// act
|
|||
rgba48.ToArgb32(ref actual); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, actual); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgba64_ToBgr24() |
|||
{ |
|||
// arrange
|
|||
var rgb48 = new Rgb48(0.08f, 0.15f, 0.30f); |
|||
var actual = default(Bgr24); |
|||
var expected = new Bgr24(20, 38, 76); |
|||
|
|||
// act
|
|||
rgb48.ToBgr24(ref actual); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, actual); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_ToBgra32() |
|||
{ |
|||
// arrange
|
|||
var rgba48 = new Rgb48(0.08f, 0.15f, 0.30f); |
|||
var actual = default(Bgra32); |
|||
var expected = new Bgra32(20, 38, 76, 255); |
|||
|
|||
// act
|
|||
rgba48.ToBgra32(ref actual); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, actual); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_PackFromRgba32_ToRgba32() |
|||
{ |
|||
// arrange
|
|||
var rgb48 = default(Rgb48); |
|||
var actual = default(Rgba32); |
|||
var expected = new Rgba32(20, 38, 76, 255); |
|||
|
|||
// act
|
|||
rgb48.PackFromRgba32(expected); |
|||
rgb48.ToRgba32(ref actual); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, actual); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_PackFromRgb48_ToRgb48() |
|||
{ |
|||
// arrange
|
|||
var input = default(Rgb48); |
|||
var actual = default(Rgb48); |
|||
var expected = new Rgb48(65535, 0, 65535); |
|||
|
|||
// act
|
|||
input.PackFromRgb48(expected); |
|||
input.ToRgb48(ref actual); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, actual); |
|||
} |
|||
|
|||
[Fact] |
|||
public void Rgb48_PackFromRgba64_ToRgba64() |
|||
{ |
|||
// arrange
|
|||
var input = default(Rgb48); |
|||
var actual = default(Rgba64); |
|||
var expected = new Rgba64(65535, 0, 65535, 65535); |
|||
|
|||
// act
|
|||
input.PackFromRgba64(expected); |
|||
input.ToRgba64(ref actual); |
|||
|
|||
// assert
|
|||
Assert.Equal(expected, actual); |
|||
} |
|||
} |
|||
} |
|||
//// Copyright (c) Six Labors and contributors.
|
|||
//// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
//using System.Numerics;
|
|||
//using SixLabors.ImageSharp.PixelFormats;
|
|||
//using Xunit;
|
|||
|
|||
//namespace SixLabors.ImageSharp.Tests.PixelFormats
|
|||
//{
|
|||
// public class Rgb48Tests
|
|||
// {
|
|||
// [Fact]
|
|||
// public void Rgb48_Values()
|
|||
// {
|
|||
// var rgb = new Rgba64(5243, 9830, 19660, 29491);
|
|||
|
|||
// Assert.Equal(5243, rgb.R);
|
|||
// Assert.Equal(9830, rgb.G);
|
|||
// Assert.Equal(19660, rgb.B);
|
|||
// Assert.Equal(29491, rgb.A);
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void Rgb48_ToVector4()
|
|||
// {
|
|||
// Assert.Equal(new Vector4(0, 0, 0, 1), new Rgb48(0, 0, 0, 0).ToVector4());
|
|||
// Assert.Equal(Vector4.One, new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue, ushort.MaxValue).ToVector4());
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void Rgb48_ToScaledVector4()
|
|||
// {
|
|||
// // arrange
|
|||
// var short2 = new Rgb48(Vector3.One);
|
|||
|
|||
// // act
|
|||
// Vector4 actual = short2.ToScaledVector4();
|
|||
|
|||
// // assert
|
|||
// Assert.Equal(1, actual.X);
|
|||
// Assert.Equal(1, actual.Y);
|
|||
// Assert.Equal(1, actual.Z);
|
|||
// Assert.Equal(1, actual.W);
|
|||
// }
|
|||
|
|||
// [Fact]
|
|||
// public void Rgb48_PackFromScaledVector4()
|
|||
// {
|
|||
// // arrange
|
|||
// var pixel = default(Rgb48);
|
|||
// var short3 = new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
|
|||
// var expected = new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
|
|||
|
|||
// // act
|
|||
// Vector4 scaled = short3.ToScaledVector4();
|
|||
// pixel.PackFromScaledVector4(scaled);
|
|||
|
|||
// // assert
|
|||
// Assert.Equal(expected, pixel);
|
|||
// }
|
|||
|
|||
// //[Fact]
|
|||
// //public void Rgb48_Clamping()
|
|||
// //{
|
|||
// // Assert.Equal(new Vector4(0, 0, 0, 1), new Rgb48(Vector3.One * -1234.0f).ToVector4());
|
|||
// // Assert.Equal(Vector4.One, new Rgb48(Vector3.One * 1234.0f).ToVector4());
|
|||
// //}
|
|||
|
|||
// //[Fact]
|
|||
// //public void Rgb48_ToRgb24()
|
|||
// //{
|
|||
// // // arrange
|
|||
// // var rgba48 = new Rgb48(0.08f, 0.15f, 0.30f);
|
|||
// // var actual = default(Rgb24);
|
|||
// // var expected = new Rgb24(20, 38, 76);
|
|||
|
|||
// // // act
|
|||
// // rgba48.ToRgb24(ref actual);
|
|||
|
|||
// // // assert
|
|||
// // Assert.Equal(expected, actual);
|
|||
// //}
|
|||
|
|||
// //[Fact]
|
|||
// //public void Rgb48_ToRgba32()
|
|||
// //{
|
|||
// // // arrange
|
|||
// // var rgba48 = new Rgb48(0.08f, 0.15f, 0.30f);
|
|||
// // var actual = default(Rgba32);
|
|||
// // var expected = new Rgba32(20, 38, 76, 255);
|
|||
|
|||
// // // act
|
|||
// // rgba48.ToRgba32(ref actual);
|
|||
|
|||
// // // assert
|
|||
// // Assert.Equal(expected, actual);
|
|||
// //}
|
|||
|
|||
// //[Fact]
|
|||
// //public void Rgb48_ToArgb32()
|
|||
// //{
|
|||
// // // arrange
|
|||
// // var rgba48 = new Rgb48(0.08f, 0.15f, 0.30f);
|
|||
// // var actual = default(Argb32);
|
|||
// // var expected = new Argb32(20, 38, 76, 255);
|
|||
|
|||
// // // act
|
|||
// // rgba48.ToArgb32(ref actual);
|
|||
|
|||
// // // assert
|
|||
// // Assert.Equal(expected, actual);
|
|||
// //}
|
|||
|
|||
// //[Fact]
|
|||
// //public void Rgba64_ToBgr24()
|
|||
// //{
|
|||
// // // arrange
|
|||
// // var rgb48 = new Rgb48(0.08f, 0.15f, 0.30f);
|
|||
// // var actual = default(Bgr24);
|
|||
// // var expected = new Bgr24(20, 38, 76);
|
|||
|
|||
// // // act
|
|||
// // rgb48.ToBgr24(ref actual);
|
|||
|
|||
// // // assert
|
|||
// // Assert.Equal(expected, actual);
|
|||
// //}
|
|||
|
|||
// //[Fact]
|
|||
// //public void Rgb48_ToBgra32()
|
|||
// //{
|
|||
// // // arrange
|
|||
// // var rgba48 = new Rgb48(0.08f, 0.15f, 0.30f);
|
|||
// // var actual = default(Bgra32);
|
|||
// // var expected = new Bgra32(20, 38, 76, 255);
|
|||
|
|||
// // // act
|
|||
// // rgba48.ToBgra32(ref actual);
|
|||
|
|||
// // // assert
|
|||
// // Assert.Equal(expected, actual);
|
|||
// //}
|
|||
|
|||
// //[Fact]
|
|||
// //public void Rgb48_PackFromRgba32_ToRgba32()
|
|||
// //{
|
|||
// // // arrange
|
|||
// // var rgb48 = default(Rgb48);
|
|||
// // var actual = default(Rgba32);
|
|||
// // var expected = new Rgba32(20, 38, 76, 255);
|
|||
|
|||
// // // act
|
|||
// // rgb48.PackFromRgba32(expected);
|
|||
// // rgb48.ToRgba32(ref actual);
|
|||
|
|||
// // // assert
|
|||
// // Assert.Equal(expected, actual);
|
|||
// //}
|
|||
|
|||
// //[Fact]
|
|||
// //public void Rgb48_PackFromRgb48_ToRgb48()
|
|||
// //{
|
|||
// // // arrange
|
|||
// // var input = default(Rgb48);
|
|||
// // var actual = default(Rgb48);
|
|||
// // var expected = new Rgb48(65535, 0, 65535);
|
|||
|
|||
// // // act
|
|||
// // input.PackFromRgb48(expected);
|
|||
// // input.ToRgb48(ref actual);
|
|||
|
|||
// // // assert
|
|||
// // Assert.Equal(expected, actual);
|
|||
// //}
|
|||
|
|||
// //[Fact]
|
|||
// //public void Rgb48_PackFromRgba64_ToRgba64()
|
|||
// //{
|
|||
// // // arrange
|
|||
// // var input = default(Rgb48);
|
|||
// // var actual = default(Rgba64);
|
|||
// // var expected = new Rgba64(65535, 0, 65535, 65535);
|
|||
|
|||
// // // act
|
|||
// // input.PackFromRgba64(expected);
|
|||
// // input.ToRgba64(ref actual);
|
|||
|
|||
// // // assert
|
|||
// // Assert.Equal(expected, actual);
|
|||
// //}
|
|||
// }
|
|||
//}
|
|||
|
|||
Loading…
Reference in new issue