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

Fix up Gray8 and Gary16 tests

af/merge-core
James Jackson-South 7 years ago
parent
5082077473
commit
86ba2b8843
2 changed files with 189 additions and 355 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. 296
      tests/ImageSharp.Tests/PixelFormats/Gray16Tests.cs
  2. 248
      tests/ImageSharp.Tests/PixelFormats/Gray8Tests.cs

296
tests/ImageSharp.Tests/PixelFormats/Gray16Tests.cs
View File

@ -15,197 +15,115 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
[InlineData(32767)]
[InlineData(42)]
public void Gray16_PackedValue_EqualsInput(ushort input)
=> Assert.Equal(input, new Gray16(input).PackedValue);
[Fact]
public void Gray16_PackFromScaledVector4()
{
// Arrange
Gray16 gray = default;
const ushort expected = 32767;
Vector4 scaled = new Gray16(expected).ToScaledVector4();
// Act
gray.PackFromScaledVector4(scaled);
ushort actual = gray.PackedValue;
// Assert
Assert.Equal(expected, actual);
}
[Theory]
[InlineData(0)]
[InlineData(65535)]
[InlineData(32767)]
public void Gray16_ToScaledVector4(ushort input)
{
// Arrange
var gray = new Gray16(input);
// Act
Vector4 actual = gray.ToScaledVector4();
// Assert
float vectorInput = input / 65535F;
Assert.Equal(vectorInput, actual.X);
Assert.Equal(vectorInput, actual.Y);
Assert.Equal(vectorInput, actual.Z);
Assert.Equal(1F, actual.W);
}
[Fact]
public void Gray16_PackFromVector4()
{
// Arrange
Gray16 gray = default;
const ushort expected = 32767;
var vector = new Gray16(expected).ToVector4();
// Act
gray.PackFromVector4(vector);
ushort actual = gray.PackedValue;
// Assert
Assert.Equal(expected, actual);
}
[Theory]
[InlineData(0)]
[InlineData(65535)]
[InlineData(32767)]
public void Gray16_ToVector4(ushort input)
{
Assert.Equal(input, new Gray16(input).PackedValue);
// Arrange
var gray = new Gray16(input);
// Act
var actual = gray.ToVector4();
// Assert
float vectorInput = input / 65535F;
Assert.Equal(vectorInput, actual.X);
Assert.Equal(vectorInput, actual.Y);
Assert.Equal(vectorInput, actual.Z);
Assert.Equal(1F, actual.W);
}
//[Theory]
//[InlineData(0)]
//[InlineData(65535)]
//[InlineData(32767)]
//public void Gray16_ToVector4(ushort input)
//{
// // arrange
// var gray = new Gray16(input);
// // act
// var actual = gray.ToVector4();
// // assert
// Assert.Equal(input, actual.X);
// Assert.Equal(input, actual.Y);
// Assert.Equal(input, actual.Z);
// Assert.Equal(1, actual.W);
//}
//[Theory]
//[InlineData(0)]
//[InlineData(65535)]
//[InlineData(32767)]
//public void Gray16_ToScaledVector4(ushort input)
//{
// // arrange
// var gray = new Gray16(input);
// // act
// var actual = gray.ToScaledVector4();
// // assert
// float scaledInput = input / 65535f;
// Assert.Equal(scaledInput, actual.X);
// Assert.Equal(scaledInput, actual.Y);
// Assert.Equal(scaledInput, actual.Z);
// Assert.Equal(1, actual.W);
//}
//[Fact]
//public void Gray16_PackFromScaledVector4()
//{
// // arrange
// Gray16 gray = default;
// int expected = 32767;
// Vector4 scaled = new Gray16((ushort)expected).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// ushort actual = gray.PackedValue;
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray16_PackFromScaledVector4_ToRgb24()
//{
// // arrange
// Rgb24 actual = default;
// Gray16 gray = default;
// var expected = new Rgb24(128, 128, 128);
// Vector4 scaled = new Gray16(32768).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray16_PackFromScaledVector4_ToRgba32()
//{
// // arrange
// Rgba32 actual = default;
// Gray16 gray = default;
// var expected = new Rgba32(128, 128, 128, 255);
// Vector4 scaled = new Gray16(32768).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray16_PackFromScaledVector4_ToBgr24()
//{
// // arrange
// Bgr24 actual = default;
// Gray16 gray = default;
// var expected = new Bgr24(128, 128, 128);
// Vector4 scaled = new Gray16(32768).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray16_PackFromScaledVector4_ToBgra32()
//{
// // arrange
// Bgra32 actual = default;
// Gray16 gray = default;
// var expected = new Bgra32(128,128,128);
// Vector4 scaled = new Gray16(32768).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray16_PackFromScaledVector4_ToArgb32()
//{
// // arrange
// Gray16 gray = default;
// Argb32 actual = default;
// var expected = new Argb32(128, 128, 128);
// Vector4 scaled = new Gray16(32768).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray16_PackFromScaledVector4_ToRgba64()
//{
// // arrange
// Gray16 gray = default;
// Rgba64 actual = default;
// var expected = new Rgba64(65535, 65535, 65535, 65535);
// Vector4 scaled = new Gray16(65535).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray16_PackFromRgb48_ToRgb48()
//{
// // arrange
// var gray = default(Gray16);
// var actual = default(Rgb48);
// var expected = new Rgb48(0, 0, 0);
// // act
// gray.PackFromRgb48(expected);
// gray.ToRgb48(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray16_PackFromRgba64_ToRgba64()
//{
// // arrange
// var gray = default(Gray16);
// var actual = default(Rgba64);
// var expected = new Rgba64(0, 0, 0, 65535);
// // act
// gray.PackFromRgba64(expected);
// gray.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
[Fact]
public void Gray16_PackFromRgba32()
{
// Arrange
Gray16 gray = default;
const byte rgb = 128;
ushort scaledRgb = ImageMaths.UpscaleFrom8BitTo16Bit(rgb);
ushort expected = ImageMaths.Get16BitBT709Luminance(scaledRgb, scaledRgb, scaledRgb);
// Act
gray.PackFromRgba32(new Rgba32(rgb, rgb, rgb));
ushort actual = gray.PackedValue;
// Assert
Assert.Equal(expected, actual);
}
[Theory]
[InlineData(0)]
[InlineData(65535)]
[InlineData(8100)]
public void Gray16_ToRgba32(ushort input)
{
// Arrange
ushort expected = ImageMaths.DownScaleFrom16BitTo8Bit(input);
var gray = new Gray16(input);
// Act
var actual = gray.ToRgba32();
// Assert
Assert.Equal(expected, actual.R);
Assert.Equal(expected, actual.G);
Assert.Equal(expected, actual.B);
Assert.Equal(byte.MaxValue, actual.A);
}
}
}

248
tests/ImageSharp.Tests/PixelFormats/Gray8Tests.cs
View File

@ -15,28 +15,23 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
[InlineData(10)]
[InlineData(42)]
public void Gray8_PackedValue_EqualsInput(byte input)
=> Assert.Equal(input, new Gray8(input).PackedValue);
[Fact]
public void Gray8_PackFromScaledVector4()
{
Assert.Equal(input, new Gray8(input).PackedValue);
}
// Arrange
Gray8 gray = default;
const byte expected = 128;
Vector4 scaled = new Gray8(expected).ToScaledVector4();
//[Theory]
//[InlineData(0, 0)]
//[InlineData(255, 1)]
//[InlineData(30)]
//public void Gray8_ToVector4(byte input)
//{
// // arrange
// var gray = new Gray8(input);
// // act
// var actual = gray.ToVector4();
// // assert
// Assert.Equal(input, actual.X);
// Assert.Equal(input, actual.Y);
// Assert.Equal(input, actual.Z);
// Assert.Equal(1, actual.W);
//}
// Act
gray.PackFromScaledVector4(scaled);
byte actual = gray.PackedValue;
// Assert
Assert.Equal(expected, actual);
}
[Theory]
[InlineData(0)]
@ -44,14 +39,14 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
[InlineData(30)]
public void Gray8_ToScaledVector4(byte input)
{
// arrange
// Arrange
var gray = new Gray8(input);
// act
var actual = gray.ToScaledVector4();
// Act
Vector4 actual = gray.ToScaledVector4();
// assert
float scaledInput = input / 255f;
// Assert
float scaledInput = input / 255F;
Assert.Equal(scaledInput, actual.X);
Assert.Equal(scaledInput, actual.Y);
Assert.Equal(scaledInput, actual.Z);
@ -59,153 +54,74 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
}
[Fact]
public void Gray8_PackFromScaledVector4()
public void Gray8_PackFromVector4()
{
// arrange
// Arrange
Gray8 gray = default;
int expected = 128;
Vector4 scaled = new Gray8(128).ToScaledVector4();
const int expected = 128;
var vector = new Gray8(expected).ToVector4();
// act
gray.PackFromScaledVector4(scaled);
// Act
gray.PackFromVector4(vector);
byte actual = gray.PackedValue;
// Assert
Assert.Equal(expected, actual);
}
[Theory]
[InlineData(0)]
[InlineData(255)]
[InlineData(30)]
public void Gray8_ToVector4(byte input)
{
// Arrange
var gray = new Gray8(input);
// Act
var actual = gray.ToVector4();
// Assert
float scaledInput = input / 255F;
Assert.Equal(scaledInput, actual.X);
Assert.Equal(scaledInput, actual.Y);
Assert.Equal(scaledInput, actual.Z);
Assert.Equal(1, actual.W);
}
[Fact]
public void Gray8_PackFromRgba32()
{
// Arrange
Gray8 gray = default;
const byte rgb = 128;
byte expected = ImageMaths.Get8BitBT709Luminance(rgb, rgb, rgb);
// Act
gray.PackFromRgba32(new Rgba32(rgb, rgb, rgb));
byte actual = gray.PackedValue;
// assert
// Assert
Assert.Equal(expected, actual);
}
//[Fact]
//public void Gray8_PackFromScaledVector4_ToRgb24()
//{
// // arrange
// Rgb24 actual = default;
// Gray8 gray = default;
// var expected = new Rgb24(128, 128, 128);
// Vector4 scaled = new Gray8(128).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray8_PackFromScaledVector4_ToRgba32()
//{
// // arrange
// Rgba32 actual = default;
// Gray8 gray = default;
// var expected = new Rgba32(128, 128, 128, 255);
// Vector4 scaled = new Gray8(128).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray8_PackFromScaledVector4_ToBgr24()
//{
// // arrange
// Bgr24 actual = default;
// Gray8 gray = default;
// var expected = new Bgr24(128, 128, 128);
// Vector4 scaled = new Gray8(128).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray8_PackFromScaledVector4_ToBgra32()
//{
// // arrange
// Bgra32 actual = default;
// Gray8 gray = default;
// var expected = new Bgra32(128,128,128);
// Vector4 scaled = new Gray8(128).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray8_PackFromScaledVector4_ToArgb32()
//{
// // arrange
// Gray8 gray = default;
// Argb32 actual = default;
// var expected = new Argb32(128, 128, 128);
// Vector4 scaled = new Gray8(128).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray8_PackFromScaledVector4_ToRgba64()
//{
// // arrange
// Gray8 gray = default;
// Rgba64 actual = default;
// var expected = new Rgba64(65535, 65535, 65535, 65535);
// Vector4 scaled = new Gray8(255).ToScaledVector4();
// // act
// gray.PackFromScaledVector4(scaled);
// gray.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray8_PackFromRgb48_ToRgb48()
//{
// // arrange
// var gray = default(Gray8);
// var actual = default(Rgb48);
// var expected = new Rgb48(0, 0, 0);
// // act
// gray.PackFromRgb48(expected);
// gray.ToRgb48(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Gray8_PackFromRgba64_ToRgba64()
//{
// // arrange
// var gray = default(Gray8);
// var actual = default(Rgba64);
// var expected = new Rgba64(0, 0, 0, 65535);
// // act
// gray.PackFromRgba64(expected);
// gray.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
[Theory]
[InlineData(0)]
[InlineData(255)]
[InlineData(30)]
public void Gray8_ToRgba32(byte input)
{
// Arrange
var gray = new Gray8(input);
// Act
var actual = gray.ToRgba32();
// Assert
Assert.Equal(input, actual.R);
Assert.Equal(input, actual.G);
Assert.Equal(input, actual.B);
Assert.Equal(byte.MaxValue, actual.A);
}
}
}
}
Write Preview
Loading…
Cancel
Save