Browse Source

Fix up pixel format tests

pull/729/head
James Jackson-South 8 years ago
parent
commit
1f7df77c5c
  1. 155
      tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs
  2. 76
      tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs
  3. 107
      tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs
  4. 76
      tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs
  5. 155
      tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs
  6. 155
      tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs
  7. 155
      tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs
  8. 107
      tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs
  9. 107
      tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs
  10. 155
      tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs
  11. 123
      tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs
  12. 140
      tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs
  13. 124
      tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs
  14. 142
      tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs
  15. 92
      tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs
  16. 287
      tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs
  17. 253
      tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs
  18. 148
      tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs
  19. 75
      tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs
  20. 2
      tests/Images/External

155
tests/ImageSharp.Tests/PixelFormats/Argb32Tests.cs

@ -66,160 +66,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
Assert.Equal(Vector4.Zero, new Argb32(Vector4.One * -1234.0f).ToVector4()); Assert.Equal(Vector4.Zero, new Argb32(Vector4.One * -1234.0f).ToVector4());
Assert.Equal(Vector4.One, new Argb32(Vector4.One * +1234.0f).ToVector4()); Assert.Equal(Vector4.One, new Argb32(Vector4.One * +1234.0f).ToVector4());
} }
//[Fact]
//public void Argb32_ToRgb24()
//{
// // arrange
// var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f);
// var actual = default(Rgb24);
// var expected = new Rgb24(0x1a, 0, 0x80);
// // act
// argb.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Argb32_ToRgba32()
//{
// // arrange
// var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f);
// var actual = default(Rgba32);
// var expected = new Rgba32(0x1a, 0, 0x80, 0);
// // act
// argb.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Argb32_ToBgr24()
//{
// // arrange
// var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f);
// var actual = default(Bgr24);
// var expected = new Bgr24(0x1a, 0, 0x80);
// // act
// argb.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Argb32_ToBgra32()
//{
// // arrange
// var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f);
// var actual = default(Bgra32);
// var expected = new Bgra32(0x1a, 0, 0x80, 0);
// // act
// argb.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Argb32_ToArgb32()
//{
// // arrange
// var argb = new Argb32(+0.1f, -0.3f, +0.5f, -0.7f);
// var actual = default(Argb32);
// var expected = new Argb32(0x1a, 0, 0x80, 0);
// // act
// argb.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Argb32_PackFromRgba32_ToRgba32()
//{
// // arrange
// var argb = default(Argb32);
// var actual = default(Rgba32);
// var expected = new Rgba32(0x1a, 0, 0x80, 0);
// // act
// argb.PackFromRgba32(expected);
// argb.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Argb32_PackFromBgra32_ToBgra32()
//{
// // arrange
// var argb = default(Argb32);
// var actual = default(Bgra32);
// var expected = new Bgra32(0x1a, 0, 0x80, 0);
// // act
// argb.PackFromBgra32(expected);
// argb.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Argb32_PackFromArgb32_ToArgb32()
//{
// // arrange
// var argb = default(Argb32);
// var actual = default(Argb32);
// var expected = new Argb32(0x1a, 0, 0x80, 0);
// // act
// argb.PackFromArgb32(expected);
// argb.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Argb32_PackFromRgb48_ToRgb48()
//{
// // arrange
// var argb = default(Argb32);
// var actual = default(Rgb48);
// var expected = new Rgb48(65535, 0, 65535);
// // act
// argb.PackFromRgb48(expected);
// argb.ToRgb48(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Argb32_PackFromRgba64_ToRgba64()
//{
// // arrange
// var argb = default(Argb32);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 0, 65535, 0);
// // act
// argb.PackFromRgba64(expected);
// argb.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

76
tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs

@ -95,81 +95,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
Assert.Equal(Vec(1, 2, 3), rgb.ToVector4()); Assert.Equal(Vec(1, 2, 3), rgb.ToVector4());
} }
//[Fact]
//public void ToRgb24()
//{
// var rgb = new Bgr24(1, 2, 3);
// var dest = default(Rgb24);
// rgb.ToRgb24(ref dest);
// Assert.Equal(new Rgb24(1, 2, 3), dest);
//}
//[Fact]
//public void ToRgba32()
//{
// var rgb = new Bgr24(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 Bgr24(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 Bgr24(1, 2, 3);
// var bgra = default(Bgra32);
// rgb.ToBgra32(ref bgra);
// Assert.Equal(new Bgra32(1, 2, 3, 255), bgra);
//}
//[Fact]
//public void Bgr24_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(Bgr24);
// 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 Bgr24_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(Bgr24);
// 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);
//}
} }
} }

107
tests/ImageSharp.Tests/PixelFormats/Bgr565Tests.cs

@ -69,112 +69,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
Assert.Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3()); Assert.Equal(Vector3.Zero, new Bgr565(Vector3.One * -1234F).ToVector3());
Assert.Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3()); Assert.Equal(Vector3.One, new Bgr565(Vector3.One * 1234F).ToVector3());
} }
//[Fact]
//public void Bgr565_ToRgb24()
//{
// // arrange
// var bgra = new Bgr565(0.1F, -0.3F, 0.5F);
// var actual = default(Rgb24);
// var expected = new Rgb24(25, 0, 132);
// // act
// bgra.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgr565_ToRgba32()
//{
// // arrange
// var bgra = new Bgr565(0.1F, -0.3F, 0.5F);
// var actual = default(Rgba32);
// var expected = new Rgba32(25, 0, 132, 255);
// // act
// bgra.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgr565_ToBgr24()
//{
// // arrange
// var bgra = new Bgr565(0.1F, -0.3F, 0.5F);
// var actual = default(Bgr24);
// var expected = new Bgr24(25, 0, 132);
// // act
// bgra.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgr565_ToBgra32()
//{
// // arrange
// var bgra = new Bgr565(0.1F, -0.3F, 0.5F);
// var actual = default(Bgra32);
// var expected = new Bgra32(25, 0, 132, 255);
// // act
// bgra.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgr565_ToArgb32()
//{
// // arrange
// var bgra = new Bgr565(0.1F, -0.3F, 0.5F);
// var actual = default(Argb32);
// var expected = new Argb32(25, 0, 132, 255);
// // act
// bgra.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgr565_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(Bgr565);
// 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 Bgr565_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(Bgr565);
// 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);
//}
} }
} }

76
tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs

@ -102,81 +102,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
Assert.Equal(Vec(1, 2, 3, 4), rgb.ToVector4()); Assert.Equal(Vec(1, 2, 3, 4), rgb.ToVector4());
} }
//[Fact]
//public void ToRgb24()
//{
// var c = new Bgra32(1, 2, 3, 4);
// var dest = default(Rgb24);
// c.ToRgb24(ref dest);
// Assert.Equal(new Rgb24(1, 2, 3), dest);
//}
//[Fact]
//public void ToRgba32()
//{
// var c = new Bgra32(1, 2, 3, 4);
// var rgba = default(Rgba32);
// c.ToRgba32(ref rgba);
// Assert.Equal(new Rgba32(1, 2, 3, 4), rgba);
//}
//[Fact]
//public void ToBgr24()
//{
// var rgb = new Bgra32(1, 2, 3, 4);
// var bgr = default(Bgr24);
// rgb.ToBgr24(ref bgr);
// Assert.Equal(new Bgr24(1, 2, 3), bgr);
//}
//[Fact]
//public void ToBgra32()
//{
// var rgb = new Bgra32(1, 2, 3, 4);
// var bgra = default(Bgra32);
// rgb.ToBgra32(ref bgra);
// Assert.Equal(new Bgra32(1, 2, 3, 4), bgra);
//}
//[Fact]
//public void Bgra32_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(Bgra32);
// 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 Bgra32_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(Bgra32);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 0, 65535, 0);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

155
tests/ImageSharp.Tests/PixelFormats/Bgra4444Tests.cs

@ -70,160 +70,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.One * -1234.0f).ToVector4()); Assert.Equal(Vector4.Zero, new Bgra4444(Vector4.One * -1234.0f).ToVector4());
Assert.Equal(Vector4.One, new Bgra4444(Vector4.One * 1234.0f).ToVector4()); Assert.Equal(Vector4.One, new Bgra4444(Vector4.One * 1234.0f).ToVector4());
} }
//[Fact]
//public void Bgra4444_ToRgb24()
//{
// // arrange
// var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Rgb24);
// var expected = new Rgb24(34, 0, 136);
// // act
// bgra.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra4444_ToRgba32()
//{
// // arrange
// var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Rgba32);
// var expected = new Rgba32(34, 0, 136, 0);
// // act
// bgra.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra4444_ToBgr24()
//{
// // arrange
// var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Bgr24);
// var expected = new Bgr24(34, 0, 136);
// // act
// bgra.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra4444_ToBgra32()
//{
// // arrange
// var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Bgra32);
// var expected = new Bgra32(34, 0, 136, 0);
// // act
// bgra.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra4444_ToArgb32()
//{
// // arrange
// var bgra = new Bgra4444(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Argb32);
// var expected = new Argb32(34, 0, 136, 0);
// // act
// bgra.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra4444_PackFromRgba32_ToRgba32()
//{
// // arrange
// var bgra = default(Bgra4444);
// var actual = default(Rgba32);
// var expected = new Rgba32(34, 0, 136, 0);
// // act
// bgra.PackFromRgba32(expected);
// bgra.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra4444_PackFromBgra32_ToBgra32()
//{
// // arrange
// var bgra = default(Bgra4444);
// var actual = default(Bgra32);
// var expected = new Bgra32(34, 0, 136, 0);
// // act
// bgra.PackFromBgra32(expected);
// bgra.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra4444_PackFromArgb32_ToArgb32()
//{
// // arrange
// var bgra = default(Bgra4444);
// var actual = default(Argb32);
// var expected = new Argb32(34, 0, 136, 0);
// // act
// bgra.PackFromArgb32(expected);
// bgra.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra4444_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(Bgra4444);
// 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 Bgra4444_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(Bgra4444);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 0, 65535, 0);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

155
tests/ImageSharp.Tests/PixelFormats/Bgra5551Tests.cs

@ -69,160 +69,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4()); Assert.Equal(Vector4.Zero, new Bgra5551(Vector4.One * -1234.0f).ToVector4());
Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4()); Assert.Equal(Vector4.One, new Bgra5551(Vector4.One * 1234.0f).ToVector4());
} }
//[Fact]
//public void Bgra5551_ToRgb24()
//{
// // arrange
// var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Rgb24);
// var expected = new Rgb24(24, 0, 131);
// // act
// bgra.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra5551_Rgba32()
//{
// // arrange
// var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Rgba32);
// var expected = new Rgba32(24, 0, 131, 0);
// // act
// bgra.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra5551_ToBgr24()
//{
// // arrange
// var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Bgr24);
// var expected = new Bgr24(24, 0, 131);
// // act
// bgra.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra5551_Bgra32()
//{
// // arrange
// var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Bgra32);
// var expected = new Bgra32(24, 0, 131, 0);
// // act
// bgra.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra5551_ToArgb32()
//{
// // arrange
// var bgra = new Bgra5551(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Argb32);
// var expected = new Argb32(24, 0, 131, 0);
// // act
// bgra.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra5551_PackFromRgba32_ToRgba32()
//{
// // arrange
// var bgra = default(Bgra5551);
// var expected = new Rgba32(24, 0, 131, 0);
// var actual = default(Rgba32);
// // act
// bgra.PackFromRgba32(expected);
// bgra.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra5551_PackFromBgra32_ToBgra32()
//{
// // arrange
// var bgra = default(Bgra5551);
// var expected = new Bgra32(24, 0, 131, 0);
// var actual = default(Bgra32);
// // act
// bgra.PackFromBgra32(expected);
// bgra.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra5551_PackFromArgb32_ToArgb32()
//{
// // arrange
// var bgra = default(Bgra5551);
// var expected = new Argb32(24, 0, 131, 0);
// var actual = default(Argb32);
// // act
// bgra.PackFromArgb32(expected);
// bgra.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Bgra5551_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(Bgra5551);
// 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 Bgra5551_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(Bgra5551);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 0, 65535, 0);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

155
tests/ImageSharp.Tests/PixelFormats/Byte4Tests.cs

@ -67,160 +67,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
Assert.Equal(Vector4.Zero, new Byte4(Vector4.One * -1234.0f).ToVector4()); Assert.Equal(Vector4.Zero, new Byte4(Vector4.One * -1234.0f).ToVector4());
Assert.Equal(Vector4.One * 255, new Byte4(Vector4.One * 1234.0f).ToVector4()); Assert.Equal(Vector4.One * 255, new Byte4(Vector4.One * 1234.0f).ToVector4());
} }
//[Fact]
//public void Byte4_ToRgb24()
//{
// // arrange
// var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f);
// var actual = default(Rgb24);
// var expected = new Rgb24(128, 0, 0);
// // act
// byte4.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Byte4_Rgba32()
//{
// // arrange
// var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f);
// var actual = default(Rgba32);
// var expected = new Rgba32(128, 0, 0, 0);
// // act
// byte4.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Byte4_ToBgr24()
//{
// // arrange
// var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f);
// var actual = default(Bgr24);
// var expected = new Bgr24(128, 0, 0);
// // act
// byte4.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Byte4_Bgra32()
//{
// // arrange
// var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f);
// var actual = default(Bgra32);
// var expected = new Bgra32(128, 0, 0, 0);
// // act
// byte4.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Byte4_Argb32()
//{
// // arrange
// var byte4 = new Byte4(127.5f, -12.3f, 0.5f, -0.7f);
// var actual = default(Argb32);
// var expected = new Argb32(128, 0, 0, 0);
// // act
// byte4.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Byte4_PackFromRgba32_ToRgba32()
//{
// // arrange
// var byte4 = default(Byte4);
// var actual = default(Rgba32);
// var expected = new Rgba32(20, 38, 0, 255);
// // act
// byte4.PackFromRgba32(expected);
// byte4.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Byte4_PackFromBgra32_ToBgra32()
//{
// // arrange
// var byte4 = default(Byte4);
// var actual = default(Bgra32);
// var expected = new Bgra32(20, 38, 0, 255);
// // act
// byte4.PackFromBgra32(expected);
// byte4.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Byte4_PackFromArgb32_ToArgb32()
//{
// // arrange
// var byte4 = default(Byte4);
// var actual = default(Argb32);
// var expected = new Argb32(20, 38, 0, 255);
// // act
// byte4.PackFromArgb32(expected);
// byte4.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Byte4_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(Byte4);
// 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 Byte4_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(Byte4);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 0, 65535, 0);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

107
tests/ImageSharp.Tests/PixelFormats/HalfSingleTests.cs

@ -66,112 +66,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
// assert // assert
Assert.Equal(expected, actual); Assert.Equal(expected, actual);
} }
//[Fact]
//public void HalfSingle_ToRgb24()
//{
// // arrange
// var halfVector = new HalfSingle(.5F);
// var actual = default(Rgb24);
// var expected = new Rgb24(128, 0, 0);
// // act
// halfVector.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfSingle_Rgba32()
//{
// // arrange
// var halfVector = new HalfSingle(.5F);
// var actual = default(Rgba32);
// var expected = new Rgba32(128, 0, 0, 255);
// // act
// halfVector.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfSingle_ToBgr24()
//{
// // arrange
// var halfVector = new HalfSingle(.5F);
// var actual = default(Bgr24);
// var expected = new Bgr24(128, 0, 0);
// // act
// halfVector.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfSingle_Bgra32()
//{
// // arrange
// var halfVector = new HalfSingle(.5F);
// var actual = default(Bgra32);
// var expected = new Bgra32(128, 0, 0, 255);
// // act
// halfVector.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfSingle_Argb32()
//{
// // arrange
// var halfVector = new HalfSingle(.5F);
// var actual = default(Argb32);
// var expected = new Argb32(128, 0, 0, 255);
// // act
// halfVector.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfSingle_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(HalfSingle);
// var actual = default(Rgb48);
// var expected = new Rgb48(65535, 0, 0);
// // act
// input.PackFromRgb48(expected);
// input.ToRgb48(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfSingle_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(HalfSingle);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 0, 0, 65535);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

107
tests/ImageSharp.Tests/PixelFormats/HalfVector2Tests.cs

@ -71,112 +71,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
// assert // assert
Assert.Equal(expected, actual); Assert.Equal(expected, actual);
} }
//[Fact]
//public void HalfVector2_ToRgb24()
//{
// // arrange
// var halfVector = new HalfVector2(.5F, .25F);
// var actual = default(Rgb24);
// var expected = new Rgb24(128, 64, 0);
// // act
// halfVector.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector2_Rgba32()
//{
// // arrange
// var halfVector = new HalfVector2(.5F, .25F);
// var actual = default(Rgba32);
// var expected = new Rgba32(128, 64, 0, 255);
// // act
// halfVector.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector2_ToBgr24()
//{
// // arrange
// var halfVector = new HalfVector2(.5F, .25F);
// var actual = default(Bgr24);
// var expected = new Bgr24(128, 64, 0);
// // act
// halfVector.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector2_Bgra32()
//{
// // arrange
// var halfVector = new HalfVector2(.5F, .25F);
// var actual = default(Bgra32);
// var expected = new Bgra32(128, 64, 0, 255);
// // act
// halfVector.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector2_Argb32()
//{
// // arrange
// var halfVector = new HalfVector2(.5F, .25F);
// var actual = default(Argb32);
// var expected = new Argb32(128, 64, 0, 255);
// // act
// halfVector.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector2_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(HalfVector2);
// var actual = default(Rgb48);
// var expected = new Rgb48(65535, 65535, 0);
// // act
// input.PackFromRgb48(expected);
// input.ToRgb48(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector2_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(HalfVector2);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 65535, 0, 65535);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

155
tests/ImageSharp.Tests/PixelFormats/HalfVector4Tests.cs

@ -65,160 +65,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
// assert // assert
Assert.Equal(expected, actual); Assert.Equal(expected, actual);
} }
//[Fact]
//public void HalfVector4_ToRgb24()
//{
// // arrange
// var halfVector = new HalfVector4(.25F, .5F, .75F, 1F);
// var actual = default(Rgb24);
// var expected = new Rgb24(64, 128, 191);
// // act
// halfVector.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector4_Rgba32()
//{
// // arrange
// var halfVector = new HalfVector4(.25F, .5F, .75F, 1F);
// var actual = default(Rgba32);
// var expected = new Rgba32(64, 128, 191, 255);
// // act
// halfVector.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector4_ToBgr24()
//{
// // arrange
// var halfVector = new HalfVector4(.25F, .5F, .75F, 1F);
// var actual = default(Bgr24);
// var expected = new Bgr24(64, 128, 191);
// // act
// halfVector.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector4_Bgra32()
//{
// // arrange
// var halfVector = new HalfVector4(.25F, .5F, .75F, 1F);
// var actual = default(Bgra32);
// var expected = new Bgra32(64, 128, 191, 255);
// // act
// halfVector.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector4_Argb32()
//{
// // arrange
// var halfVector = new HalfVector4(.25F, .5F, .75F, 1F);
// var actual = default(Argb32);
// var expected = new Argb32(64, 128, 191, 255);
// // act
// halfVector.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector4_PackFromRgba32_ToRgba32()
//{
// // arrange
// var halVector = default(HalfVector4);
// var actual = default(Rgba32);
// var expected = new Rgba32(64, 128, 191, 255);
// // act
// halVector.PackFromRgba32(expected);
// halVector.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector4_PackFromBgra32_ToBgra32()
//{
// // arrange
// var halVector = default(HalfVector4);
// var actual = default(Bgra32);
// var expected = new Bgra32(64, 128, 191, 255);
// // act
// halVector.PackFromBgra32(expected);
// halVector.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector4_PackFromArgb32_ToArgb32()
//{
// // arrange
// var halVector = default(HalfVector4);
// var actual = default(Argb32);
// var expected = new Argb32(64, 128, 191, 255);
// // act
// halVector.PackFromArgb32(expected);
// halVector.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void HalfVector4_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(HalfVector4);
// 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 HalfVector4_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(HalfVector4);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 0, 65535, 0);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

123
tests/ImageSharp.Tests/PixelFormats/NormalizedByte2Tests.cs

@ -66,128 +66,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
// assert // assert
Assert.Equal(expected, actual); Assert.Equal(expected, actual);
} }
//[Fact]
//public void NormalizedByte2_PackFromRgba32()
//{
// // arrange
// var byte2 = new NormalizedByte2();
// var rgba = new Rgba32(141, 90, 0, 0);
// int expected = 0xda0d;
// // act
// byte2.PackFromRgba32(rgba);
// ushort actual = byte2.PackedValue;
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte2_ToRgb24()
//{
// // arrange
// var short4 = new NormalizedByte2(0.1f, -0.3f);
// var actual = default(Rgb24);
// var expected = new Rgb24(141, 90, 0);
// // act
// short4.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte2_ToRgba32()
//{
// // arrange
// var short4 = new NormalizedByte2(0.1f, -0.3f);
// var actual = default(Rgba32);
// var expected = new Rgba32(141, 90, 0, 255);
// // act
// short4.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte2_ToBgr24()
//{
// // arrange
// var short4 = new NormalizedByte2(0.1f, -0.3f);
// var actual = default(Bgr24);
// var expected = new Bgr24(141, 90, 0);
// // act
// short4.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte2_ToBgra32()
//{
// // arrange
// var short4 = new NormalizedByte2(0.1f, -0.3f);
// var actual = default(Bgra32);
// var expected = new Bgra32(141, 90, 0, 255);
// // act
// short4.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte2_ToArgb32()
//{
// // arrange
// var short4 = new NormalizedByte2(0.1f, -0.3f);
// var actual = default(Argb32);
// var expected = new Argb32(141, 90, 0, 255);
// // act
// short4.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte2_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(NormalizedByte2);
// var actual = default(Rgb48);
// var expected = new Rgb48(65535, 65535, 0);
// // act
// input.PackFromRgb48(expected);
// input.ToRgb48(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte2_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(NormalizedByte2);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 65535, 0, 65535);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

140
tests/ImageSharp.Tests/PixelFormats/NormalizedByte4Tests.cs

@ -60,145 +60,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
// assert // assert
Assert.Equal(expected, actual); Assert.Equal(expected, actual);
} }
//[Fact]
//public void NormalizedByte4_ToRgb24()
//{
// // arrange
// var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Rgb24);
// var expected = new Rgb24(141, 90, 192);
// // act
// short4.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte4_ToRgba32()
//{
// // arrange
// var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Rgba32);
// var expected = new Rgba32(141, 90, 192, 39);
// // act
// short4.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte4_ToBgr24()
//{
// // arrange
// var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Bgr24);
// var expected = new Bgr24(141, 90, 192);
// // act
// short4.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte4_ToArgb32()
//{
// // arrange
// var short4 = new NormalizedByte4(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Argb32);
// var expected = new Argb32(141, 90, 192, 39);
// // act
// short4.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte4_PackFromRgba32_ToRgba32()
//{
// // arrange
// var short4 = default(NormalizedByte4);
// var actual = default(Rgba32);
// var expected = new Rgba32(9, 115, 202, 127);
// // act
// short4.PackFromRgba32(new Rgba32(9, 115, 202, 127));
// short4.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte4_PackFromBgra32_ToRgba32()
//{
// // arrange
// var actual = default(Bgra32);
// var short4 = default(NormalizedByte4);
// var expected = new Bgra32(9, 115, 202, 127);
// // act
// short4.PackFromBgra32(expected);
// short4.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte4_PackFromArgb32_ToRgba32()
//{
// // arrange
// var short4 = default(NormalizedByte4);
// var actual = default(Argb32);
// var expected = new Argb32(9, 115, 202, 127);
// // act
// short4.PackFromArgb32(expected);
// short4.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte4_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(NormalizedByte4);
// var actual = default(Rgb48);
// var expected = new Rgb48(65535, 65535, 0);
// // act
// input.PackFromRgb48(expected);
// input.ToRgb48(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedByte4_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(NormalizedByte4);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 65535, 0, 65535);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

124
tests/ImageSharp.Tests/PixelFormats/NormalizedShort2Tests.cs

@ -69,129 +69,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
// assert // assert
Assert.Equal(expected, actual); Assert.Equal(expected, actual);
} }
//[Fact]
//public void NormalizedShort2_PackFromRgba32_ToRgb24()
//{
// // arrange
// var actual = default(Rgb24);
// var short2 = new NormalizedShort2();
// var rgba = new Rgba32(141, 90, 0, 0);
// var expected = new Rgb24(141, 90, 0);
// // act
// short2.PackFromRgba32(rgba);
// short2.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort2_ToRgb24()
//{
// // arrange
// var short2 = new NormalizedShort2(0.1f, -0.3f);
// var actual = default(Rgb24);
// var expected = new Rgb24(141, 90, 0);
// // act
// short2.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort2_ToRgba32()
//{
// // arrange
// var short2 = new NormalizedShort2(0.1f, -0.3f);
// var actual = default(Rgba32);
// var expected = new Rgba32(141, 90, 0, 255);
// // act
// short2.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort2_ToBgr24()
//{
// // arrange
// var short2 = new NormalizedShort2(0.1f, -0.3f);
// var actual = default(Bgr24);
// var expected = new Bgr24(141, 90, 0);
// // act
// short2.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort2_ToBgra32()
//{
// // arrange
// var short2 = new NormalizedShort2(0.1f, -0.3f);
// var actual = default(Bgra32);
// var expected = new Bgra32(141, 90, 0, 255);
// // act
// short2.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort2_ToArgb32()
//{
// // arrange
// var short2 = new NormalizedShort2(0.1f, -0.3f);
// var actual = default(Argb32);
// var expected = new Argb32(141, 90, 0, 255);
// // act
// short2.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort2_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(NormalizedShort2);
// var actual = default(Rgb48);
// var expected = new Rgb48(65535, 65535, 0);
// // act
// input.PackFromRgb48(expected);
// input.ToRgb48(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort2_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(NormalizedShort2);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 65535, 0, 65535);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

142
tests/ImageSharp.Tests/PixelFormats/NormalizedShort4Tests.cs

@ -52,7 +52,7 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
// arrange // arrange
var pixel = default(NormalizedShort4); var pixel = default(NormalizedShort4);
Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4(); Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4();
ulong expected = (ulong)0x7FFF7FFF7FFF7FFF; ulong expected = 0x7FFF7FFF7FFF7FFF;
// act // act
pixel.PackFromScaledVector4(scaled); pixel.PackFromScaledVector4(scaled);
@ -61,145 +61,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
// assert // assert
Assert.Equal(expected, actual); Assert.Equal(expected, actual);
} }
//[Fact]
//public void NormalizedShort4_ToRgb24()
//{
// // arrange
// var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Rgb24);
// var expected = new Rgb24(141, 90, 192);
// // act
// short4.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort4_ToRgba32()
//{
// // arrange
// var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Rgba32);
// var expected = new Rgba32(141, 90, 192, 39);
// // act
// short4.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort4_ToBgr24()
//{
// // arrange
// var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Bgr24);
// var expected = new Bgr24(141, 90, 192);
// // act
// short4.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort4_ToArgb32()
//{
// // arrange
// var short4 = new NormalizedShort4(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Argb32);
// var expected = new Argb32(141, 90, 192, 39);
// // act
// short4.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort4_PackFromRgba32_ToRgba32()
//{
// // arrange
// var short4 = default(NormalizedShort4);
// var expected = new Rgba32(9, 115, 202, 127);
// var actual = default(Rgba32);
// // act
// short4.PackFromRgba32(expected);
// short4.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort4_PackFromBgra32_ToRgba32()
//{
// // arrange
// var short4 = default(NormalizedShort4);
// var actual = default(Bgra32);
// var expected = new Bgra32(9, 115, 202, 127);
// // act
// short4.PackFromBgra32(expected);
// short4.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort4_PackFromArgb32_ToRgba32()
//{
// // arrange
// var short4 = default(NormalizedShort4);
// var actual = default(Argb32);
// var expected = new Argb32(9, 115, 202, 127);
// // act
// short4.PackFromArgb32(expected);
// short4.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort4_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(NormalizedShort4);
// var actual = default(Rgb48);
// var expected = new Rgb48(65535, 65535, 0);
// // act
// input.PackFromRgb48(expected);
// input.ToRgb48(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void NormalizedShort4_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(NormalizedShort4);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 65535, 0, 65535);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

92
tests/ImageSharp.Tests/PixelFormats/Rg32Tests.cs

@ -68,97 +68,5 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
Assert.Equal(Vector2.Zero, new Rg32(Vector2.One * -1234.0f).ToVector2()); Assert.Equal(Vector2.Zero, new Rg32(Vector2.One * -1234.0f).ToVector2());
Assert.Equal(Vector2.One, new Rg32(Vector2.One * 1234.0f).ToVector2()); Assert.Equal(Vector2.One, new Rg32(Vector2.One * 1234.0f).ToVector2());
} }
//[Fact]
//public void Rg32_ToRgb24()
//{
// // arrange
// var rg32 = new Rg32(0.1f, -0.3f);
// var actual = default(Rgb24);
// var expected = new Rgb24(25, 0, 0);
// // act
// rg32.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rg32_ToRgba32()
//{
// // arrange
// var rg32 = new Rg32(0.1f, -0.3f);
// var actual = default(Rgba32);
// var expected = new Rgba32(25, 0, 0, 255);
// // act
// rg32.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rg32_ToBgr24()
//{
// // arrange
// var rg32 = new Rg32(0.1f, -0.3f);
// var actual = default(Bgr24);
// var expected = new Bgr24(25, 0, 0);
// // act
// rg32.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rg32_ToArgb32()
//{
// // arrange
// var rg32 = new Rg32(0.1f, -0.3f);
// var actual = default(Argb32);
// var expected = new Argb32(25, 0, 0, 255);
// // act
// rg32.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rg32_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(Rg32);
// var actual = default(Rgb48);
// var expected = new Rgb48(65535, 65535, 0);
// // act
// input.PackFromRgb48(expected);
// input.ToRgb48(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rg32_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(Rg32);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 65535, 0, 65535);
// // act
// input.PackFromRgba64(expected);
// input.ToRgba64(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
} }
} }

287
tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs

@ -1,175 +1,112 @@
//// Copyright (c) Six Labors and contributors. // Copyright (c) Six Labors and contributors.
//// Licensed under the Apache License, Version 2.0. // Licensed under the Apache License, Version 2.0.
//using System; using System.Numerics;
//using System.Numerics; using SixLabors.ImageSharp.PixelFormats;
//using SixLabors.ImageSharp.PixelFormats; using Xunit;
//using Xunit;
namespace SixLabors.ImageSharp.Tests.PixelFormats
//namespace SixLabors.ImageSharp.Tests.PixelFormats {
//{ public class Rgb24Tests
// public class Rgb24Tests {
// { public static readonly TheoryData<byte, byte, byte> ColorData =
// public static readonly TheoryData<byte, byte, byte> ColorData = new TheoryData<byte, byte, byte>()
// new TheoryData<byte, byte, byte>() { { 1, 2, 3 }, { 4, 5, 6 }, { 0, 255, 42 } }; {
{ 1, 2, 3 },
// [Theory] { 4, 5, 6 },
// [MemberData(nameof(ColorData))] { 0, 255, 42 }
// public void Constructor(byte r, byte g, byte b) };
// {
// var p = new Rgb24(r, g, b); [Theory]
[MemberData(nameof(ColorData))]
// Assert.Equal(r, p.R); public void Constructor(byte r, byte g, byte b)
// Assert.Equal(g, p.G); {
// Assert.Equal(b, p.B); var p = new Rgb24(r, g, b);
// }
Assert.Equal(r, p.R);
// [Fact] Assert.Equal(g, p.G);
// public unsafe void ByteLayoutIsSequentialRgb() Assert.Equal(b, p.B);
// { }
// var color = new Rgb24(1, 2, 3);
// byte* ptr = (byte*)&color; [Fact]
public unsafe void ByteLayoutIsSequentialRgb()
// Assert.Equal(1, ptr[0]); {
// Assert.Equal(2, ptr[1]); var color = new Rgb24(1, 2, 3);
// Assert.Equal(3, ptr[2]); byte* ptr = (byte*)&color;
// }
Assert.Equal(1, ptr[0]);
// [Theory] Assert.Equal(2, ptr[1]);
// [MemberData(nameof(ColorData))] Assert.Equal(3, ptr[2]);
// public void Equals_WhenTrue(byte r, byte g, byte b) }
// {
// var x = new Rgb24(r, g, b); [Theory]
// var y = new Rgb24(r, g, b); [MemberData(nameof(ColorData))]
public void Equals_WhenTrue(byte r, byte g, byte b)
// Assert.True(x.Equals(y)); {
// Assert.True(x.Equals((object)y)); var x = new Rgb24(r, g, b);
// Assert.Equal(x.GetHashCode(), y.GetHashCode()); var y = new Rgb24(r, g, b);
// }
Assert.True(x.Equals(y));
// [Theory] Assert.True(x.Equals((object)y));
// [InlineData(1, 2, 3, 1, 2, 4)] Assert.Equal(x.GetHashCode(), y.GetHashCode());
// [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) [Theory]
// { [InlineData(1, 2, 3, 1, 2, 4)]
// var a = new Rgb24(r1, g1, b1); [InlineData(0, 255, 0, 0, 244, 0)]
// var b = new Rgb24(r2, g2, b2); [InlineData(1, 255, 0, 0, 255, 0)]
public void Equals_WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
// Assert.False(a.Equals(b)); {
// Assert.False(a.Equals((object)b)); var a = new Rgb24(r1, g1, b1);
// } var b = new Rgb24(r2, g2, b2);
// [Fact] Assert.False(a.Equals(b));
// public void PackFromRgba32() Assert.False(a.Equals((object)b));
// { }
// var rgb = default(Rgb24);
// rgb.PackFromRgba32(new Rgba32(1, 2, 3, 4)); [Fact]
public void PackFromRgba32()
// Assert.Equal(1, rgb.R); {
// Assert.Equal(2, rgb.G); var rgb = default(Rgb24);
// Assert.Equal(3, rgb.B); rgb.PackFromRgba32(new Rgba32(1, 2, 3, 4));
// }
Assert.Equal(1, rgb.R);
// private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4( Assert.Equal(2, rgb.G);
// r / 255f, Assert.Equal(3, rgb.B);
// g / 255f, }
// b / 255f,
// a / 255f); private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
r / 255f,
// [Fact] g / 255f,
// public void PackFromVector4() b / 255f,
// { a / 255f);
// var rgb = default(Rgb24);
// rgb.PackFromVector4(Vec(1, 2, 3, 4)); [Fact]
public void PackFromVector4()
// Assert.Equal(1, rgb.R); {
// Assert.Equal(2, rgb.G); var rgb = default(Rgb24);
// Assert.Equal(3, rgb.B); rgb.PackFromVector4(Vec(1, 2, 3, 4));
// }
Assert.Equal(1, rgb.R);
// [Fact] Assert.Equal(2, rgb.G);
// public void ToVector4() Assert.Equal(3, rgb.B);
// { }
// var rgb = new Rgb24(1, 2, 3);
[Fact]
// Assert.Equal(Vec(1, 2, 3), rgb.ToVector4()); public void ToVector4()
// } {
var rgb = new Rgb24(1, 2, 3);
// [Fact]
// public void ToRgb24() Assert.Equal(Vec(1, 2, 3), rgb.ToVector4());
// { }
// var rgb = new Rgb24(1, 2, 3);
// var dest = default(Rgb24); [Fact]
public void ToRgba32()
// rgb.ToRgb24(ref dest); {
var rgb = new Rgb24(1, 2, 3);
// Assert.Equal(rgb, dest); var rgba = rgb.ToRgba32();
// }
Assert.Equal(new Rgba32(1, 2, 3, 255), rgba);
// [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);
// }
// }
//}

253
tests/ImageSharp.Tests/PixelFormats/Rgb48Tests.cs

@ -1,192 +1,61 @@
//// Copyright (c) Six Labors and contributors. // Copyright (c) Six Labors and contributors.
//// Licensed under the Apache License, Version 2.0. // Licensed under the Apache License, Version 2.0.
//using System.Numerics; using System.Numerics;
//using SixLabors.ImageSharp.PixelFormats; using SixLabors.ImageSharp.PixelFormats;
//using Xunit; using Xunit;
//namespace SixLabors.ImageSharp.Tests.PixelFormats namespace SixLabors.ImageSharp.Tests.PixelFormats
//{ {
// public class Rgb48Tests public class Rgb48Tests
// { {
// [Fact] [Fact]
// public void Rgb48_Values() public void Rgb48_Values()
// { {
// var rgb = new Rgba64(5243, 9830, 19660, 29491); var rgb = new Rgba64(5243, 9830, 19660, 29491);
// Assert.Equal(5243, rgb.R); Assert.Equal(5243, rgb.R);
// Assert.Equal(9830, rgb.G); Assert.Equal(9830, rgb.G);
// Assert.Equal(19660, rgb.B); Assert.Equal(19660, rgb.B);
// Assert.Equal(29491, rgb.A); Assert.Equal(29491, rgb.A);
// } }
// [Fact] [Fact]
// public void Rgb48_ToVector4() public void Rgb48_ToVector4()
// { => Assert.Equal(Vector4.One, new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue).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()
=> Assert.Equal(Vector4.One, new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue).ToVector4());
// [Fact]
// public void Rgb48_ToScaledVector4() [Fact]
// { public void Rgb48_PackFromScaledVector4()
// // arrange {
// var short2 = new Rgb48(Vector3.One); // arrange
var pixel = default(Rgb48);
// // act var short3 = new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
// Vector4 actual = short2.ToScaledVector4(); var expected = new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue);
// // assert // act
// Assert.Equal(1, actual.X); Vector4 scaled = short3.ToScaledVector4();
// Assert.Equal(1, actual.Y); pixel.PackFromScaledVector4(scaled);
// Assert.Equal(1, actual.Z);
// Assert.Equal(1, actual.W); // assert
// } Assert.Equal(expected, pixel);
}
// [Fact]
// public void Rgb48_PackFromScaledVector4() [Fact]
// { public void Rgb48_ToRgba32()
// // arrange {
// var pixel = default(Rgb48); // arrange
// var short3 = new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue); var rgba48 = new Rgb48(5140, 9766, 19532);
// var expected = new Rgb48(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue); var expected = new Rgba32(20, 38, 76, 255);
// // act // act
// Vector4 scaled = short3.ToScaledVector4(); var actual = rgba48.ToRgba32();
// pixel.PackFromScaledVector4(scaled);
// assert
// // assert Assert.Equal(expected, actual);
// 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);
// //}
// }
//}

148
tests/ImageSharp.Tests/PixelFormats/Rgba1010102Tests.cs

@ -71,144 +71,18 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
Assert.Equal(Vector4.One, new Rgba1010102(Vector4.One * 1234.0f).ToVector4()); Assert.Equal(Vector4.One, new Rgba1010102(Vector4.One * 1234.0f).ToVector4());
} }
//[Fact] [Fact]
//public void Rgba1010102_ToRgb24() public void Rgba1010102_ToRgba32()
//{ {
// // arrange // arrange
// var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f); var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Rgb24); var expected = new Rgba32(25, 0, 128, 0);
// var expected = new Rgb24(25, 0, 128);
// // act
// rgba.ToRgb24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rgba1010102_ToRgba32()
//{
// // arrange
// var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Rgba32);
// var expected = new Rgba32(25, 0, 128, 0);
// // act
// rgba.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rgba1010102_ToBgr24()
//{
// // arrange
// var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Bgr24);
// var expected = new Bgr24(25, 0, 128);
// // act
// rgba.ToBgr24(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rgba1010102_ToBgra32()
//{
// // arrange
// var rgba = new Rgba1010102(0.1f, -0.3f, 0.5f, -0.7f);
// var actual = default(Bgra32);
// var expected = new Bgra32(25, 0, 128, 0);
// // act
// rgba.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rgba1010102_PackFromRgba32_ToRgba32()
//{
// // arrange
// var rgba = default(Rgba1010102);
// var expected = new Rgba32(25, 0, 128, 0);
// var actual = default(Rgba32);
// // act
// rgba.PackFromRgba32(expected);
// rgba.ToRgba32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rgba1010102_PackFromBgra32_ToBgra32()
//{
// // arrange
// var rgba = default(Rgba1010102);
// var expected = new Bgra32(25, 0, 128, 0);
// var actual = default(Bgra32);
// // act
// rgba.PackFromBgra32(expected);
// rgba.ToBgra32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rgba1010102_PackFromArgb32_ToArgb32()
//{
// // arrange
// var rgba = default(Rgba1010102);
// var expected = new Argb32(25, 0, 128, 0);
// var actual = default(Argb32);
// // act
// rgba.PackFromArgb32(expected);
// rgba.ToArgb32(ref actual);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rgba1010102_PackFromRgb48_ToRgb48()
//{
// // arrange
// var input = default(Rgba1010102);
// 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 Rgba1010102_PackFromRgba64_ToRgba64()
//{
// // arrange
// var input = default(Rgba1010102);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 0, 65535, 65535);
// // act // act
// input.PackFromRgba64(expected); var actual = rgba.ToRgba32();
// input.ToRgba64(ref actual);
// // assert // assert
// Assert.Equal(expected, actual); Assert.Equal(expected, actual);
//} }
} }
} }

75
tests/ImageSharp.Tests/PixelFormats/Rgba64Tests.cs

@ -77,70 +77,19 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
Assert.Equal(Vector4.One, one.ToVector4()); Assert.Equal(Vector4.One, one.ToVector4());
} }
//[Fact] [Fact]
//public void Rgba64_ToRgba32() public void Rgba64_ToRgba32()
//{ {
// // arrange // arrange
// var rgba64 = new Rgba64( var rgba64 = new Rgba64(5140, 9766, 19532, 29555);
// (ushort)(0.08f * ushort.MaxValue), var actual = default(Rgba32);
// (ushort)(0.15f * ushort.MaxValue), var expected = new Rgba32(20, 38, 76, 115);
// (ushort)(0.30f * ushort.MaxValue),
// (ushort)(0.45f * ushort.MaxValue));
// var actual = default(Rgba32);
// var expected = new Rgba32(20, 38, 76, 115);
// // act
// actual = rgba64.ToRgba32();
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rgba64_PackFromRgba32_ToRgba32()
//{
// // arrange
// var rgba64 = default(Rgba64);
// var actual = default(Rgba32);
// var expected = new Rgba32(20, 38, 76, 115);
// // act
// rgba64.PackFromRgba32(expected);
// actual = rgba64.ToRgba32();
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rgb48_PackFromRgb48()
//{
// // arrange
// var input = default(Rgba64);
// var actual = default(Rgb48);
// var expected = new Rgb48(65535, 0, 65535);
// // act
// input.PackFromRgb48(expected);
// // assert
// Assert.Equal(expected, actual);
//}
//[Fact]
//public void Rgba64_PackFromRgba64()
//{
// // arrange
// var input = default(Rgba64);
// var actual = default(Rgba64);
// var expected = new Rgba64(65535, 0, 65535, 0);
// // act // act
// input.PackFromRgba64(expected); actual = rgba64.ToRgba32();
// actual.PackFromScaledVector4(input.ToScaledVector4());
// // assert // assert
// Assert.Equal(expected, actual); Assert.Equal(expected, actual);
//} }
} }
} }

2
tests/Images/External

@ -1 +1 @@
Subproject commit 1a807d17b4cf5ab50558983d4137614cabe96ce3 Subproject commit ee90e5f32218027744b5d40058b587cc1047b76f
Loading…
Cancel
Save