mirror of https://github.com/SixLabors/ImageSharp
Anton Firszov
8 years ago
23 changed files with 761 additions and 492 deletions
@ -1,337 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
using SixLabors.ImageSharp.Formats; |
|||
using SixLabors.ImageSharp.IO; |
|||
using Moq; |
|||
using Xunit; |
|||
using SixLabors.ImageSharp.Advanced; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests |
|||
{ |
|||
/// <summary>
|
|||
/// Tests the <see cref="Image"/> class.
|
|||
/// </summary>
|
|||
public partial class ImageLoadTests : IDisposable |
|||
{ |
|||
private readonly Mock<IFileSystem> fileSystem; |
|||
private Image<Rgba32> returnImage; |
|||
private Mock<IImageDecoder> localDecoder; |
|||
private readonly string FilePath; |
|||
private readonly IImageFormatDetector localMimeTypeDetector; |
|||
private readonly Mock<IImageFormat> localImageFormatMock; |
|||
|
|||
public Configuration LocalConfiguration { get; private set; } |
|||
public byte[] Marker { get; private set; } |
|||
public MemoryStream DataStream { get; private set; } |
|||
public byte[] DecodedData { get; private set; } |
|||
|
|||
public ImageLoadTests() |
|||
{ |
|||
this.returnImage = new Image<Rgba32>(1, 1); |
|||
|
|||
this.localImageFormatMock = new Mock<IImageFormat>(); |
|||
|
|||
this.localDecoder = new Mock<IImageDecoder>(); |
|||
this.localMimeTypeDetector = new MockImageFormatDetector(this.localImageFormatMock.Object); |
|||
this.localDecoder.Setup(x => x.Decode<Rgba32>(It.IsAny<Configuration>(), It.IsAny<Stream>())) |
|||
|
|||
.Callback<Configuration, Stream>((c, s) => |
|||
{ |
|||
using (var ms = new MemoryStream()) |
|||
{ |
|||
s.CopyTo(ms); |
|||
this.DecodedData = ms.ToArray(); |
|||
} |
|||
}) |
|||
.Returns(this.returnImage); |
|||
|
|||
this.fileSystem = new Mock<IFileSystem>(); |
|||
|
|||
this.LocalConfiguration = new Configuration |
|||
{ |
|||
FileSystem = this.fileSystem.Object |
|||
}; |
|||
this.LocalConfiguration.ImageFormatsManager.AddImageFormatDetector(this.localMimeTypeDetector); |
|||
this.LocalConfiguration.ImageFormatsManager.SetDecoder(this.localImageFormatMock.Object, this.localDecoder.Object); |
|||
|
|||
TestFormat.RegisterGlobalTestFormat(); |
|||
this.Marker = Guid.NewGuid().ToByteArray(); |
|||
this.DataStream = TestFormat.GlobalTestFormat.CreateStream(this.Marker); |
|||
|
|||
this.FilePath = Guid.NewGuid().ToString(); |
|||
this.fileSystem.Setup(x => x.OpenRead(this.FilePath)).Returns(this.DataStream); |
|||
|
|||
TestFileSystem.RegisterGlobalTestFormat(); |
|||
TestFileSystem.Global.AddFile(this.FilePath, this.DataStream); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromStream() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.DataStream); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromNoneSeekableStream() |
|||
{ |
|||
NoneSeekableStream stream = new NoneSeekableStream(this.DataStream); |
|||
Image<Rgba32> img = Image.Load<Rgba32>(stream); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromStreamWithType() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.DataStream); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(TestFormat.GlobalTestFormat.Sample<Rgba32>(), img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
|
|||
[Fact] |
|||
public void LoadFromStreamWithConfig() |
|||
{ |
|||
Stream stream = new MemoryStream(); |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.LocalConfiguration, stream); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, stream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromStreamWithTypeAndConfig() |
|||
{ |
|||
Stream stream = new MemoryStream(); |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.LocalConfiguration, stream); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, stream)); |
|||
} |
|||
|
|||
|
|||
[Fact] |
|||
public void LoadFromStreamWithDecoder() |
|||
{ |
|||
Stream stream = new MemoryStream(); |
|||
Image<Rgba32> img = Image.Load<Rgba32>(stream, this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, stream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromStreamWithTypeAndDecoder() |
|||
{ |
|||
Stream stream = new MemoryStream(); |
|||
Image<Rgba32> img = Image.Load<Rgba32>(stream, this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, stream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytes() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.DataStream.ToArray()); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytesWithType() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.DataStream.ToArray()); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(TestFormat.GlobalTestFormat.Sample<Rgba32>(), img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
|
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytesWithConfig() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.LocalConfiguration, this.DataStream.ToArray()); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, It.IsAny<Stream>())); |
|||
|
|||
Assert.Equal(this.DataStream.ToArray(), this.DecodedData); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytesWithTypeAndConfig() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.LocalConfiguration, this.DataStream.ToArray()); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, It.IsAny<Stream>())); |
|||
|
|||
Assert.Equal(this.DataStream.ToArray(), this.DecodedData); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytesWithDecoder() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.DataStream.ToArray(), this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, It.IsAny<Stream>())); |
|||
Assert.Equal(this.DataStream.ToArray(), this.DecodedData); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytesWithTypeAndDecoder() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.DataStream.ToArray(), this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, It.IsAny<Stream>())); |
|||
Assert.Equal(this.DataStream.ToArray(), this.DecodedData); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFile() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.DataStream); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFileWithType() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.DataStream); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(TestFormat.GlobalTestFormat.Sample<Rgba32>(), img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFileWithConfig() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.LocalConfiguration, this.FilePath); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, this.DataStream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFileWithTypeAndConfig() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.LocalConfiguration, this.FilePath); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, this.DataStream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFileWithDecoder() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.FilePath, this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, this.DataStream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFileWithTypeAndDecoder() |
|||
{ |
|||
Image<Rgba32> img = Image.Load<Rgba32>(this.FilePath, this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, this.DataStream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromPixelData_Pixels() |
|||
{ |
|||
var img = Image.LoadPixelData<Rgba32>(new Rgba32[] { |
|||
Rgba32.Black, Rgba32.White, |
|||
Rgba32.White, Rgba32.Black, |
|||
}, 2, 2); |
|||
|
|||
Assert.NotNull(img); |
|||
using (var px = img.Lock()) |
|||
{ |
|||
Assert.Equal(Rgba32.Black, px[0, 0]); |
|||
Assert.Equal(Rgba32.White, px[0, 1]); |
|||
|
|||
Assert.Equal(Rgba32.White, px[1, 0]); |
|||
Assert.Equal(Rgba32.Black, px[1, 1]); |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromPixelData_Bytes() |
|||
{ |
|||
var img = Image.LoadPixelData<Rgba32>(new byte[] { |
|||
0,0,0,255, // 0,0
|
|||
255,255,255,255, // 0,1
|
|||
255,255,255,255, // 1,0
|
|||
0,0,0,255, // 1,1
|
|||
}, 2, 2); |
|||
|
|||
Assert.NotNull(img); |
|||
using (var px = img.Lock()) |
|||
{ |
|||
Assert.Equal(Rgba32.Black, px[0, 0]); |
|||
Assert.Equal(Rgba32.White, px[0, 1]); |
|||
|
|||
Assert.Equal(Rgba32.White, px[1, 0]); |
|||
Assert.Equal(Rgba32.Black, px[1, 1]); |
|||
} |
|||
} |
|||
|
|||
|
|||
[Fact] |
|||
public void LoadsImageWithoutThrowingCrcException() |
|||
{ |
|||
var image1Provider = TestImageProvider<Rgba32>.File(TestImages.Png.VersioningImage1); |
|||
|
|||
using (Image<Rgba32> img = image1Provider.GetImage()) |
|||
{ |
|||
Assert.Equal(166036, img.Frames.RootFrame.GetPixelSpan().Length); |
|||
} |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
// clean up the global object;
|
|||
this.returnImage?.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,63 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
using Xunit; |
|||
// ReSharper disable InconsistentNaming
|
|||
|
|||
namespace SixLabors.ImageSharp.Tests |
|||
{ |
|||
public partial class ImageTests |
|||
{ |
|||
public class Load_BasicCases |
|||
{ |
|||
[Fact] |
|||
public void ByteArray() |
|||
{ |
|||
Assert.Throws<ArgumentNullException>(() => |
|||
{ |
|||
Image.Load<Rgba32>((byte[])null); |
|||
}); |
|||
|
|||
var file = TestFile.Create(TestImages.Bmp.Car); |
|||
using (var image = Image.Load<Rgba32>(file.Bytes)) |
|||
{ |
|||
Assert.Equal(600, image.Width); |
|||
Assert.Equal(450, image.Height); |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void FileSystemPath() |
|||
{ |
|||
var file = TestFile.Create(TestImages.Bmp.Car); |
|||
using (var image = Image.Load<Rgba32>(file.FullPath)) |
|||
{ |
|||
Assert.Equal(600, image.Width); |
|||
Assert.Equal(450, image.Height); |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void FileSystemPath_FileNotFound() |
|||
{ |
|||
System.IO.FileNotFoundException ex = Assert.Throws<System.IO.FileNotFoundException>( |
|||
() => |
|||
{ |
|||
Image.Load<Rgba32>(Guid.NewGuid().ToString()); |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void FileSystemPath_NullPath() |
|||
{ |
|||
ArgumentNullException ex = Assert.Throws<ArgumentNullException>( |
|||
() => |
|||
{ |
|||
Image.Load<Rgba32>((string)null); |
|||
}); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,338 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.IO; |
|||
|
|||
using Moq; |
|||
|
|||
using SixLabors.ImageSharp.Advanced; |
|||
using SixLabors.ImageSharp.Formats; |
|||
using SixLabors.ImageSharp.IO; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
using Xunit; |
|||
// ReSharper disable InconsistentNaming
|
|||
|
|||
namespace SixLabors.ImageSharp.Tests |
|||
{ |
|||
public partial class ImageTests |
|||
{ |
|||
/// <summary>
|
|||
/// Tests the <see cref="Image"/> class.
|
|||
/// </summary>
|
|||
public class Load_ComplexCases : IDisposable |
|||
{ |
|||
private readonly Mock<IFileSystem> fileSystem; |
|||
private readonly Image<Rgba32> returnImage; |
|||
private readonly Mock<IImageDecoder> localDecoder; |
|||
private readonly string FilePath; |
|||
private readonly IImageFormatDetector localMimeTypeDetector; |
|||
private readonly Mock<IImageFormat> localImageFormatMock; |
|||
|
|||
public Configuration LocalConfiguration { get; private set; } |
|||
public byte[] Marker { get; private set; } |
|||
public MemoryStream DataStream { get; private set; } |
|||
public byte[] DecodedData { get; private set; } |
|||
|
|||
public Load_ComplexCases() |
|||
{ |
|||
this.returnImage = new Image<Rgba32>(1, 1); |
|||
|
|||
this.localImageFormatMock = new Mock<IImageFormat>(); |
|||
|
|||
this.localDecoder = new Mock<IImageDecoder>(); |
|||
this.localMimeTypeDetector = new MockImageFormatDetector(this.localImageFormatMock.Object); |
|||
this.localDecoder.Setup(x => x.Decode<Rgba32>(It.IsAny<Configuration>(), It.IsAny<Stream>())) |
|||
|
|||
.Callback<Configuration, Stream>((c, s) => |
|||
{ |
|||
using (var ms = new MemoryStream()) |
|||
{ |
|||
s.CopyTo(ms); |
|||
this.DecodedData = ms.ToArray(); |
|||
} |
|||
}) |
|||
.Returns(this.returnImage); |
|||
|
|||
this.fileSystem = new Mock<IFileSystem>(); |
|||
|
|||
this.LocalConfiguration = new Configuration |
|||
{ |
|||
FileSystem = this.fileSystem.Object |
|||
}; |
|||
this.LocalConfiguration.ImageFormatsManager.AddImageFormatDetector(this.localMimeTypeDetector); |
|||
this.LocalConfiguration.ImageFormatsManager.SetDecoder(this.localImageFormatMock.Object, this.localDecoder.Object); |
|||
|
|||
TestFormat.RegisterGlobalTestFormat(); |
|||
this.Marker = Guid.NewGuid().ToByteArray(); |
|||
this.DataStream = TestFormat.GlobalTestFormat.CreateStream(this.Marker); |
|||
|
|||
this.FilePath = Guid.NewGuid().ToString(); |
|||
this.fileSystem.Setup(x => x.OpenRead(this.FilePath)).Returns(this.DataStream); |
|||
|
|||
TestFileSystem.RegisterGlobalTestFormat(); |
|||
TestFileSystem.Global.AddFile(this.FilePath, this.DataStream); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromStream() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.DataStream); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromNoneSeekableStream() |
|||
{ |
|||
var stream = new NoneSeekableStream(this.DataStream); |
|||
var img = Image.Load<Rgba32>(stream); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromStreamWithType() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.DataStream); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(TestFormat.GlobalTestFormat.Sample<Rgba32>(), img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
|
|||
[Fact] |
|||
public void LoadFromStreamWithConfig() |
|||
{ |
|||
Stream stream = new MemoryStream(); |
|||
var img = Image.Load<Rgba32>(this.LocalConfiguration, stream); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, stream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromStreamWithTypeAndConfig() |
|||
{ |
|||
Stream stream = new MemoryStream(); |
|||
var img = Image.Load<Rgba32>(this.LocalConfiguration, stream); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, stream)); |
|||
} |
|||
|
|||
|
|||
[Fact] |
|||
public void LoadFromStreamWithDecoder() |
|||
{ |
|||
Stream stream = new MemoryStream(); |
|||
var img = Image.Load<Rgba32>(stream, this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, stream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromStreamWithTypeAndDecoder() |
|||
{ |
|||
Stream stream = new MemoryStream(); |
|||
var img = Image.Load<Rgba32>(stream, this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, stream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytes() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.DataStream.ToArray()); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytesWithType() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.DataStream.ToArray()); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(TestFormat.GlobalTestFormat.Sample<Rgba32>(), img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
|
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytesWithConfig() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.LocalConfiguration, this.DataStream.ToArray()); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, It.IsAny<Stream>())); |
|||
|
|||
Assert.Equal(this.DataStream.ToArray(), this.DecodedData); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytesWithTypeAndConfig() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.LocalConfiguration, this.DataStream.ToArray()); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, It.IsAny<Stream>())); |
|||
|
|||
Assert.Equal(this.DataStream.ToArray(), this.DecodedData); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytesWithDecoder() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.DataStream.ToArray(), this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, It.IsAny<Stream>())); |
|||
Assert.Equal(this.DataStream.ToArray(), this.DecodedData); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromBytesWithTypeAndDecoder() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.DataStream.ToArray(), this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, It.IsAny<Stream>())); |
|||
Assert.Equal(this.DataStream.ToArray(), this.DecodedData); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFile() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.DataStream); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFileWithType() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.DataStream); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(TestFormat.GlobalTestFormat.Sample<Rgba32>(), img); |
|||
|
|||
TestFormat.GlobalTestFormat.VerifyDecodeCall(this.Marker, Configuration.Default); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFileWithConfig() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.LocalConfiguration, this.FilePath); |
|||
|
|||
Assert.NotNull(img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, this.DataStream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFileWithTypeAndConfig() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.LocalConfiguration, this.FilePath); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
|
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(this.LocalConfiguration, this.DataStream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFileWithDecoder() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.FilePath, this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, this.DataStream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromFileWithTypeAndDecoder() |
|||
{ |
|||
var img = Image.Load<Rgba32>(this.FilePath, this.localDecoder.Object); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(this.returnImage, img); |
|||
this.localDecoder.Verify(x => x.Decode<Rgba32>(Configuration.Default, this.DataStream)); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromPixelData_Pixels() |
|||
{ |
|||
var img = Image.LoadPixelData<Rgba32>(new Rgba32[] { |
|||
Rgba32.Black, Rgba32.White, |
|||
Rgba32.White, Rgba32.Black, |
|||
}, 2, 2); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(Rgba32.Black, img[0, 0]); |
|||
Assert.Equal(Rgba32.White, img[0, 1]); |
|||
|
|||
Assert.Equal(Rgba32.White, img[1, 0]); |
|||
Assert.Equal(Rgba32.Black, img[1, 1]); |
|||
} |
|||
|
|||
[Fact] |
|||
public void LoadFromPixelData_Bytes() |
|||
{ |
|||
var img = Image.LoadPixelData<Rgba32>(new byte[] { |
|||
0,0,0,255, // 0,0
|
|||
255,255,255,255, // 0,1
|
|||
255,255,255,255, // 1,0
|
|||
0,0,0,255, // 1,1
|
|||
}, 2, 2); |
|||
|
|||
Assert.NotNull(img); |
|||
Assert.Equal(Rgba32.Black, img[0, 0]); |
|||
Assert.Equal(Rgba32.White, img[0, 1]); |
|||
|
|||
Assert.Equal(Rgba32.White, img[1, 0]); |
|||
Assert.Equal(Rgba32.Black, img[1, 1]); |
|||
} |
|||
|
|||
|
|||
[Fact] |
|||
public void LoadsImageWithoutThrowingCrcException() |
|||
{ |
|||
var image1Provider = TestImageProvider<Rgba32>.File(TestImages.Png.VersioningImage1); |
|||
|
|||
using (Image<Rgba32> img = image1Provider.GetImage()) |
|||
{ |
|||
Assert.Equal(166036, img.Frames.RootFrame.GetPixelSpan().Length); |
|||
} |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
// clean up the global object;
|
|||
this.returnImage?.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,70 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
// ReSharper disable InconsistentNaming
|
|||
|
|||
using System; |
|||
using SixLabors.ImageSharp.Formats.Png; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests |
|||
{ |
|||
using SixLabors.ImageSharp.Formats; |
|||
|
|||
public partial class ImageTests |
|||
{ |
|||
public class Save |
|||
{ |
|||
[Fact] |
|||
public void DetecedEncoding() |
|||
{ |
|||
string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageTests)); |
|||
string file = System.IO.Path.Combine(dir, "DetecedEncoding.png"); |
|||
|
|||
using (var image = new Image<Rgba32>(10, 10)) |
|||
{ |
|||
image.Save(file); |
|||
} |
|||
|
|||
using (var img = Image.Load(file, out IImageFormat mime)) |
|||
{ |
|||
Assert.Equal("image/png", mime.DefaultMimeType); |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void WhenExtensionIsUnknown_Throws() |
|||
{ |
|||
string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageTests)); |
|||
string file = System.IO.Path.Combine(dir, "UnknownExtensionsEncoding_Throws.tmp"); |
|||
|
|||
NotSupportedException ex = Assert.Throws<NotSupportedException>( |
|||
() => |
|||
{ |
|||
using (var image = new Image<Rgba32>(10, 10)) |
|||
{ |
|||
image.Save(file); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
[Fact] |
|||
public void SetEncoding() |
|||
{ |
|||
string dir = TestEnvironment.CreateOutputDirectory(nameof(ImageTests)); |
|||
string file = System.IO.Path.Combine(dir, "SetEncoding.dat"); |
|||
|
|||
using (var image = new Image<Rgba32>(10, 10)) |
|||
{ |
|||
image.Save(file, new PngEncoder()); |
|||
} |
|||
|
|||
using (var img = Image.Load(file, out var mime)) |
|||
{ |
|||
Assert.Equal("image/png", mime.DefaultMimeType); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,24 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using SixLabors.Memory; |
|||
using Xunit; |
|||
|
|||
// ReSharper disable InconsistentNaming
|
|||
namespace SixLabors.ImageSharp.Tests |
|||
{ |
|||
public partial class ImageTests |
|||
{ |
|||
public class WrapMemory |
|||
{ |
|||
[Fact] |
|||
public void ConsumedBuffer_IsMemoryOwner_ReturnsFalse() |
|||
{ |
|||
var memory = new Memory<int>(new int[55]); |
|||
var buffer = new ConsumedBuffer<int>(memory); |
|||
Assert.False(buffer.IsMemoryOwner); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,50 @@ |
|||
using System; |
|||
using System.Buffers; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests |
|||
{ |
|||
using SixLabors.ImageSharp.Advanced; |
|||
using SixLabors.ImageSharp.PixelFormats; |
|||
|
|||
class TestMemoryManager<T> : MemoryManager<T> |
|||
where T : struct, IPixel<T> |
|||
{ |
|||
public TestMemoryManager(T[] pixelArray) |
|||
{ |
|||
this.PixelArray = pixelArray; |
|||
} |
|||
|
|||
public T[] PixelArray { get; } |
|||
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
} |
|||
|
|||
public override Span<T> GetSpan() |
|||
{ |
|||
return this.PixelArray; |
|||
} |
|||
|
|||
public override MemoryHandle Pin(int elementIndex = 0) |
|||
{ |
|||
throw new NotImplementedException(); |
|||
} |
|||
|
|||
public override void Unpin() |
|||
{ |
|||
throw new NotImplementedException(); |
|||
} |
|||
|
|||
public static TestMemoryManager<T> CreateAsCopyOfPixelData(Span<T> pixelData) |
|||
{ |
|||
var pixelArray = new T[pixelData.Length]; |
|||
pixelData.CopyTo(pixelArray); |
|||
return new TestMemoryManager<T>(pixelArray); |
|||
} |
|||
|
|||
public static TestMemoryManager<T> CreateAsCopyOfPixelData(Image<T> image) |
|||
{ |
|||
return CreateAsCopyOfPixelData(image.GetPixelSpan()); |
|||
} |
|||
} |
|||
} |
|||
Loading…
Reference in new issue