public async Task WhenNoMatchingFormatFoundAsync_ReturnsNull()
{
var asyncStream = new AsyncStreamWrapper(this.DataStream, () => false);
(IImageInfo ImageInfo, IImageFormat Format)info = await Image.IdentifyWithFormatAsync(new Configuration(), asyncStream);
Assert.Null(info.ImageInfo);
}
public Lexer(TranslationUnit tu, IAsyncStream <char> input, bool preprocessorTokens, bool outputTrivia)
{
TranslationUnit = tu;
InputStream = input;
PreprocessorTokens = preprocessorTokens;
OutputTrivia = outputTrivia;
Filename = tu.CurrentFilename;
OutputStream = new AsyncStreamWrapper <Token>(Lex(), Token.Eof);
}
public async Task FromStreamAsync_CustomConfiguration()
{
var asyncStream = new AsyncStreamWrapper(this.DataStream, () => false);
(IImageInfo ImageInfo, IImageFormat Format)info = await Image.IdentifyWithFormatAsync(this.LocalConfiguration, asyncStream);
Assert.Equal(this.LocalImageInfo, info.ImageInfo);
Assert.Equal(this.LocalImageFormat, info.Format);
}
public async Task FromStreamAsync_GlobalConfiguration_NoFormat()
{
using (var stream = new MemoryStream(this.ActualImageBytes))
{
var asyncStream = new AsyncStreamWrapper(stream, () => false);
IImageInfo info = await Image.IdentifyAsync(asyncStream);
Assert.NotNull(info);
}
}
public async Task FromNonSeekableStreamAsync_GlobalConfiguration_NoFormat()
{
using var stream = new MemoryStream(ActualImageBytes);
using var nonSeekableStream = new NonSeekableStream(stream);
var asyncStream = new AsyncStreamWrapper(nonSeekableStream, () => false);
IImageInfo info = await Image.IdentifyAsync(asyncStream);
Assert.NotNull(info);
}
public async Task FromStreamAsync_GlobalConfiguration()
{
using (var stream = new MemoryStream(this.ActualImageBytes))
{
var asyncStream = new AsyncStreamWrapper(stream, () => false);
(IImageInfo ImageInfo, IImageFormat Format)res = await Image.IdentifyWithFormatAsync(asyncStream);
Assert.Equal(ExpectedImageSize, res.ImageInfo.Size());
Assert.Equal(ExpectedGlobalFormat, res.Format);
}
}
public async Task SaveAsync_NeverCallsSyncMethods(string filename)
{
using (var image = new Image <Rgba32>(5, 5))
{
IImageEncoder encoder = image.DetectEncoder(filename);
using (var stream = new MemoryStream())
{
var asyncStream = new AsyncStreamWrapper(stream, () => false);
await image.SaveAsync(asyncStream, encoder);
}
}
}
public async Task SaveAsync_WithNonSeekableStream_IsCancellable()
{
using var image = new Image <Rgba32>(4000, 4000);
var encoder = new PngEncoder()
{
CompressionLevel = PngCompressionLevel.BestCompression
};
using var stream = new MemoryStream();
var asyncStream = new AsyncStreamWrapper(stream, () => false);
var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromTicks(1));
await Assert.ThrowsAnyAsync <TaskCanceledException>(() =>
image.SaveAsync(asyncStream, encoder, cts.Token));
}
public async Task SaveAsync_WithNonSeekableStream_IsCancellable()
{
using var image = new Image <Rgba32>(4000, 4000);
var encoder = new PngEncoder()
{
CompressionLevel = PngCompressionLevel.BestCompression
};
using var stream = new MemoryStream();
var asyncStream = new AsyncStreamWrapper(stream, () => false);
var cts = new CancellationTokenSource();
var pausedStream = new PausedStream(asyncStream);
pausedStream.OnWaiting(s =>
{
cts.Cancel();
pausedStream.Release();
});
await Assert.ThrowsAsync <TaskCanceledException>(async() => await image.SaveAsync(pausedStream, encoder, cts.Token));
}
public async Task TestAsyncStreamWrapper()
{
var ints = new AsyncStreamWrapper <int>(generator(), 0xFF);
for (int i = 0; i < 5; i++)
{
Assert.False(await ints.Eof());
Assert.Equal(await ints.Peek(), i);
Assert.Equal(await ints.Read(), i);
}
ints.PutBack(4);
ints.PutBack(3);
for (int i = 3; i < 10; i++)
{
Assert.False(await ints.Eof());
Assert.Equal(await ints.Peek(), i);
Assert.Equal(await ints.Read(), i);
}
Assert.True(await ints.Eof());
Assert.Equal(await ints.Peek(), ints.Sentinel);
Assert.True(await ints.Eof());
}
public async Task SaveStreamWithMime(string filename, string mimeType)
{
using (var image = new Image <Rgba32>(5, 5))
{
string ext = Path.GetExtension(filename);
IImageFormat format = image.GetConfiguration().ImageFormatsManager.FindFormatByFileExtension(ext);
Assert.Equal(mimeType, format.DefaultMimeType);
using (var stream = new MemoryStream())
{
var asyncStream = new AsyncStreamWrapper(stream, () => false);
await image.SaveAsync(asyncStream, format);
stream.Position = 0;
(Image Image, IImageFormat Format)imf = await Image.LoadWithFormatAsync(stream);
Assert.Equal(format, imf.Format);
Assert.Equal(mimeType, imf.Format.DefaultMimeType);
imf.Image.Dispose();
}
}
}
public CharacterStream(TextReader reader)
{
Reader = reader;
Stream = new AsyncStreamWrapper <char>(Enumerate(), Sentinel);
}
