tons of new overloads

src/ImageSharp/Image.FromFile.cs

@@ -80,6 +80,125 @@ namespace SixLabors.ImageSharp
             }
         }
 
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static Task<IImageInfo> IdentifyAsync(string filePath)
+            => IdentifyAsync(Configuration.Default, filePath, default);
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static Task<IImageInfo> IdentifyAsync(Configuration configuration, string filePath)
+            => IdentifyAsync(configuration, filePath, default);
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static Task<IImageInfo> IdentifyAsync(string filePath, CancellationToken cancellationToken)
+            => IdentifyAsync(Configuration.Default, filePath, cancellationToken);
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static async Task<IImageInfo> IdentifyAsync(Configuration configuration, string filePath, CancellationToken cancellationToken)
+        {
+            (IImageInfo ImageInfo, IImageFormat Format) res = await IdentifyWithFormatAsync(configuration, filePath, cancellationToken);
+            return res.ImageInfo;
+        }
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(string filePath)
+            => IdentifyWithFormatAsync(Configuration.Default, filePath, default);
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(
+            string filePath,
+            CancellationToken cancellationToken)
+            => IdentifyWithFormatAsync(Configuration.Default, filePath, cancellationToken);
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(
+            Configuration configuration,
+            string filePath)
+            => IdentifyWithFormatAsync(configuration, filePath, default);
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="filePath">The image file to open and to read the header from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static async Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(
+            Configuration configuration,
+            string filePath,
+            CancellationToken cancellationToken)
+        {
+            Guard.NotNull(configuration, nameof(configuration));
+            using Stream stream = configuration.FileSystem.OpenRead(filePath);
+            return await IdentifyWithFormatAsync(configuration, stream, cancellationToken)
+                .ConfigureAwait(false);
+        }
+
         /// <summary>
         /// Create a new instance of the <see cref="Image"/> class from the given file.
         /// </summary>
@@ -182,6 +301,20 @@ namespace SixLabors.ImageSharp
             }
         }
 
+        /// <summary>
+        /// Create a new instance of the <see cref="Image"/> class from the given file.
+        /// </summary>
+        /// <param name="path">The file path to the image.</param>
+        /// <param name="decoder">The decoder.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The path is null.</exception>
+        /// <exception cref="ArgumentNullException">The decoder is null.</exception>
+        /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        public static Task<Image> LoadAsync(string path, IImageDecoder decoder)
+            => LoadAsync(Configuration.Default, path, decoder, default);
+
         /// <summary>
         /// Create a new instance of the <see cref="Image"/> class from the given file.
         /// </summary>
@@ -197,6 +330,22 @@ namespace SixLabors.ImageSharp
         public static Task<Image> LoadAsync(Configuration configuration, string path, IImageDecoder decoder)
             => LoadAsync(configuration, path, decoder, default);
 
+        /// <summary>
+        /// Create a new instance of the <see cref="Image"/> class from the given file.
+        /// </summary>
+        /// <param name="path">The file path to the image.</param>
+        /// <param name="decoder">The decoder.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The path is null.</exception>
+        /// <exception cref="ArgumentNullException">The decoder is null.</exception>
+        /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        public static Task<Image<TPixel>> LoadAsync<TPixel>(string path, IImageDecoder decoder)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => LoadAsync<TPixel>(Configuration.Default, path, decoder, default);
+
         /// <summary>
         /// Create a new instance of the <see cref="Image"/> class from the given file.
         /// </summary>
@@ -260,6 +409,20 @@ namespace SixLabors.ImageSharp
             return LoadAsync<TPixel>(configuration, stream, decoder, cancellationToken);
         }
 
+        /// <summary>
+        /// Create a new instance of the <see cref="Image"/> class from the given file.
+        /// </summary>
+        /// <param name="path">The file path to the image.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The path is null.</exception>
+        /// <exception cref="UnknownImageFormatException">Image format not recognised.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <returns>A <see cref="Task{Image}"/> representing the asynchronous operation.</returns>
+        public static Task<Image<TPixel>> LoadAsync<TPixel>(string path)
+            where TPixel : unmanaged, IPixel<TPixel>
+            => LoadAsync<TPixel>(Configuration.Default, path, default(CancellationToken));
+
         /// <summary>
         /// Create a new instance of the <see cref="Image"/> class from the given file.
         /// </summary>

src/ImageSharp/Image.FromStream.cs

@@ -135,9 +135,26 @@ namespace SixLabors.ImageSharp
         /// A <see cref="Task{IImageInfo}"/> representing the asynchronous operation or null if
         /// a suitable detector is not found.
         /// </returns>
-        public static async Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream)
+        public static Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream)
+            => IdentifyAsync(configuration, stream, default);
+
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="stream">The image stream to read the information from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The stream is null.</exception>
+        /// <exception cref="NotSupportedException">The stream is not readable.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <returns>
+        /// A <see cref="Task{IImageInfo}"/> representing the asynchronous operation or null if
+        /// a suitable detector is not found.
+        /// </returns>
+        public static async Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
         {
-            (IImageInfo ImageInfo, IImageFormat Format) res = await IdentifyWithFormatAsync(configuration, stream).ConfigureAwait(false);
+            (IImageInfo ImageInfo, IImageFormat Format) res = await IdentifyWithFormatAsync(configuration, stream, cancellationToken).ConfigureAwait(false);
             return res.ImageInfo;
         }
 
@@ -197,6 +214,24 @@ namespace SixLabors.ImageSharp
                 (s, ct) => InternalIdentityAsync(s, configuration ?? Configuration.Default, ct),
                 default);
 
+        /// <summary>
+        /// Reads the raw image information from the specified stream without fully decoding it.
+        /// </summary>
+        /// <param name="stream">The image stream to read the information from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <exception cref="ArgumentNullException">The configuration is null.</exception>
+        /// <exception cref="ArgumentNullException">The stream is null.</exception>
+        /// <exception cref="NotSupportedException">The stream is not readable.</exception>
+        /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
+        /// <returns>
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
+        /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
+        /// </returns>
+        public static Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(
+            Stream stream,
+            CancellationToken cancellationToken)
+            => IdentifyWithFormatAsync(Configuration.Default, stream, cancellationToken);
+
         /// <summary>
         /// Reads the raw image information from the specified stream without fully decoding it.
         /// </summary>
@@ -208,7 +243,7 @@ namespace SixLabors.ImageSharp
         /// <exception cref="NotSupportedException">The stream is not readable.</exception>
         /// <exception cref="InvalidImageContentException">Image contains invalid content.</exception>
         /// <returns>
-        /// The <see cref="Task{ValueTuple}"/> representing the asyncronous operation with the parameter type
+        /// The <see cref="Task{ValueTuple}"/> representing the asynchronous operation with the parameter type
         /// <see cref="IImageInfo"/> property set to null if suitable info detector is not found.
         /// </returns>
         public static Task<(IImageInfo ImageInfo, IImageFormat Format)> IdentifyWithFormatAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)

tests/ImageSharp.Tests/Image/ImageTests.Decode_Cancellation.cs

@@ -27,7 +27,7 @@ namespace SixLabors.ImageSharp.Tests
             [Theory]
             [InlineData(false)]
             [InlineData(true)]
-            public async Task LoadAsync_Specific_Stream_WhenCancelledDuringRead(bool isInputStreamSeekable)
+            public async Task LoadAsync_Specific_Stream(bool isInputStreamSeekable)
             {
                 this.isTestStreamSeekable = isInputStreamSeekable;
                 _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
@@ -38,7 +38,7 @@ namespace SixLabors.ImageSharp.Tests
             [Theory]
             [InlineData(false)]
             [InlineData(true)]
-            public async Task LoadAsync_Agnostic_Stream_WhenCancelledDuringRead(bool isInputStreamSeekable)
+            public async Task LoadAsync_Agnostic_Stream(bool isInputStreamSeekable)
             {
                 this.isTestStreamSeekable = isInputStreamSeekable;
                 _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
@@ -47,7 +47,7 @@ namespace SixLabors.ImageSharp.Tests
             }
 
             [Fact]
-            public async Task LoadAsync_Agnostic_Path_WhenCancelledDuringRead()
+            public async Task LoadAsync_Agnostic_Path()
             {
                 this.isTestStreamSeekable = true;
                 _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
@@ -56,7 +56,7 @@ namespace SixLabors.ImageSharp.Tests
             }
 
             [Fact]
-            public async Task LoadAsync_Specific_Path_WhenCancelledDuringRead()
+            public async Task LoadAsync_Specific_Path()
             {
                 this.isTestStreamSeekable = true;
                 _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
@@ -64,6 +64,54 @@ namespace SixLabors.ImageSharp.Tests
                 await Assert.ThrowsAsync<TaskCanceledException>(() => Image.LoadAsync<Rgb24>(this.TopLevelConfiguration, this.MockFilePath, this.cts.Token));
             }
 
+            [Theory]
+            [InlineData(false)]
+            [InlineData(true)]
+            public async Task IdentifyAsync_Stream(bool isInputStreamSeekable)
+            {
+                this.isTestStreamSeekable = isInputStreamSeekable;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyAsync(this.TopLevelConfiguration, this.DataStream, this.cts.Token));
+            }
+
+            [Fact]
+            public async Task IdentifyAsync_CustomConfiguration_Path()
+            {
+                this.isTestStreamSeekable = true;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyAsync(this.TopLevelConfiguration, this.MockFilePath, this.cts.Token));
+            }
+
+            [Theory]
+            [InlineData(false)]
+            [InlineData(true)]
+            public async Task IdentifyWithFormatAsync_CustomConfiguration_Stream(bool isInputStreamSeekable)
+            {
+                this.isTestStreamSeekable = isInputStreamSeekable;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyWithFormatAsync(this.TopLevelConfiguration, this.DataStream, this.cts.Token));
+            }
+
+            [Fact]
+            public async Task IdentifyWithFormatAsync_CustomConfiguration_Path()
+            {
+                this.isTestStreamSeekable = true;
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyWithFormatAsync(this.TopLevelConfiguration, this.MockFilePath, this.cts.Token));
+            }
+
+            [Fact]
+            public async Task IdentifyWithFormatAsync_DefaultConfiguration_Stream()
+            {
+                _ = Task.Factory.StartNew(this.DoCancel, TaskCreationOptions.LongRunning);
+
+                await Assert.ThrowsAsync<TaskCanceledException>(() => Image.IdentifyWithFormatAsync(this.DataStream, this.cts.Token));
+            }
+
             private async Task DoCancel()
             {
                 // wait until we reach the middle of the steam

tests/ImageSharp.Tests/Image/ImageTests.Identify.cs

@@ -19,6 +19,8 @@ namespace SixLabors.ImageSharp.Tests
         {
             private static readonly string ActualImagePath = TestFile.GetInputFileFullPath(TestImages.Bmp.F);
 
+            private static readonly Size ExpectedImageSize = new Size(108, 202);
+
             private byte[] ActualImageBytes => TestFile.Create(TestImages.Bmp.F).Bytes;
 
             private IImageInfo LocalImageInfo => this.localImageInfoMock.Object;
@@ -33,7 +35,7 @@ namespace SixLabors.ImageSharp.Tests
             {
                 IImageInfo info = Image.Identify(this.ActualImageBytes, out IImageFormat type);
 
-                Assert.NotNull(info);
+                Assert.Equal(ExpectedImageSize, info.Size());
                 Assert.Equal(ExpectedGlobalFormat, type);
             }
 
@@ -131,13 +133,46 @@ namespace SixLabors.ImageSharp.Tests
                 using (var stream = new MemoryStream(this.ActualImageBytes))
                 {
                     var asyncStream = new AsyncStreamWrapper(stream, () => false);
-                    (IImageInfo ImageInfo, IImageFormat Format) info = await Image.IdentifyWithFormatAsync(asyncStream);
+                    (IImageInfo ImageInfo, IImageFormat Format) res = await Image.IdentifyWithFormatAsync(asyncStream);
 
-                    Assert.NotNull(info.ImageInfo);
-                    Assert.Equal(ExpectedGlobalFormat, info.Format);
+                    Assert.Equal(ExpectedImageSize, res.ImageInfo.Size());
+                    Assert.Equal(ExpectedGlobalFormat, res.Format);
                 }
             }
 
+            [Fact]
+            public async Task FromPathAsync_CustomConfiguration()
+            {
+                IImageInfo info = await Image.IdentifyAsync(this.LocalConfiguration, this.MockFilePath);
+                Assert.Equal(this.LocalImageInfo, info);
+            }
+
+            [Fact]
+            public async Task IdentifyWithFormatAsync_FromPath_CustomConfiguration()
+            {
+                (IImageInfo ImageInfo, IImageFormat Format) info = await Image.IdentifyWithFormatAsync(this.LocalConfiguration, this.MockFilePath);
+                Assert.NotNull(info.ImageInfo);
+                Assert.Equal(this.LocalImageFormat, info.Format);
+            }
+
+            [Fact]
+            public async Task IdentifyWithFormatAsync_FromPath_GlobalConfiguration()
+            {
+                (IImageInfo ImageInfo, IImageFormat Format) res = await Image.IdentifyWithFormatAsync(ActualImagePath);
+
+                Assert.Equal(ExpectedImageSize, res.ImageInfo.Size());
+                Assert.Equal(ExpectedGlobalFormat, res.Format);
+            }
+
+            [Fact]
+            public async Task FromPathAsync_GlobalConfiguration()
+            {
+                IImageInfo info = await Image.IdentifyAsync(ActualImagePath);
+
+                Assert.Equal(ExpectedImageSize, info.Size());
+            }
+
+
             [Fact]
             public async Task FromStreamAsync_CustomConfiguration()
             {

tests/ImageSharp.Tests/Image/ImageTests.Load_FileSystemPath_UseDefaultConfiguration.cs

@@ -25,102 +25,80 @@ namespace SixLabors.ImageSharp.Tests
             [Fact]
             public void Path_Specific()
             {
-                using (var img = Image.Load<Rgba32>(this.Path))
-                {
-                    VerifyDecodedImage(img);
-                }
+                using var img = Image.Load<Rgba32>(this.Path);
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public void Path_Agnostic()
             {
-                using (var img = Image.Load(this.Path))
-                {
-                    VerifyDecodedImage(img);
-                }
+                using var img = Image.Load(this.Path);
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public async Task Path_Agnostic_Async()
             {
-                using (var img = await Image.LoadAsync(this.Path))
-                {
-                    VerifyDecodedImage(img);
-                }
+                using var img = await Image.LoadAsync(this.Path);
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public async Task Path_Specific_Async()
             {
-                using (var img = await Image.LoadAsync<Rgb24>(Configuration.Default, this.Path))
-                {
-                    VerifyDecodedImage(img);
-                }
+                using var img = await Image.LoadAsync<Rgb24>(this.Path);
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public async Task Path_Agnostic_Configuration_Async()
             {
-                using (var img = await Image.LoadAsync(Configuration.Default, this.Path))
-                {
-                    VerifyDecodedImage(img);
-                }
+                using var img = await Image.LoadAsync(this.Path);
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public void Path_Decoder_Specific()
             {
-                using (var img = Image.Load<Rgba32>(this.Path, new BmpDecoder()))
-                {
-                    VerifyDecodedImage(img);
-                }
+                using var img = Image.Load<Rgba32>(this.Path, new BmpDecoder());
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public void Path_Decoder_Agnostic()
             {
-                using (var img = Image.Load(this.Path, new BmpDecoder()))
-                {
-                    VerifyDecodedImage(img);
-                }
+                using var img = Image.Load(this.Path, new BmpDecoder());
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public async Task Path_Decoder_Agnostic_Async()
             {
-                using (var img = await Image.LoadAsync(Configuration.Default, this.Path, new BmpDecoder()))
-                {
-                    VerifyDecodedImage(img);
-                }
+                using var img = await Image.LoadAsync(this.Path, new BmpDecoder());
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public async Task Path_Decoder_Specific_Async()
             {
-                using (var img = await Image.LoadAsync<Rgb24>(Configuration.Default, this.Path, new BmpDecoder()))
-                {
-                    VerifyDecodedImage(img);
-                }
+                using var img = await Image.LoadAsync<Rgb24>(this.Path, new BmpDecoder());
+                VerifyDecodedImage(img);
             }
 
             [Fact]
             public void Path_OutFormat_Specific()
             {
-                using (var img = Image.Load<Rgba32>(this.Path, out IImageFormat format))
-                {
-                    VerifyDecodedImage(img);
-                    Assert.IsType<BmpFormat>(format);
-                }
+                using var img = Image.Load<Rgba32>(this.Path, out IImageFormat format);
+                VerifyDecodedImage(img);
+                Assert.IsType<BmpFormat>(format);
             }
 
             [Fact]
             public void Path_OutFormat_Agnostic()
             {
-                using (var img = Image.Load(this.Path, out IImageFormat format))
-                {
-                    VerifyDecodedImage(img);
-                    Assert.IsType<BmpFormat>(format);
-                }
+                using var img = Image.Load(this.Path, out IImageFormat format);
+                VerifyDecodedImage(img);
+                Assert.IsType<BmpFormat>(format);
             }
 
             [Fact]
@@ -142,6 +120,20 @@ namespace SixLabors.ImageSharp.Tests
                             Image.Load<Rgba32>((string)null);
                         });
             }
+
+            [Fact]
+            public Task Async_WhenFileNotFound_Throws()
+            {
+                return Assert.ThrowsAsync<System.IO.FileNotFoundException>(
+                    () => Image.LoadAsync<Rgba32>(Guid.NewGuid().ToString()));
+            }
+
+            [Fact]
+            public Task Async_WhenPathIsNull_Throws()
+            {
+                return Assert.ThrowsAsync<ArgumentNullException>(
+                    () => Image.LoadAsync<Rgba32>((string)null));
+            }
         }
     }
 }

tests/ImageSharp.Tests/TestFormat.cs

@@ -197,7 +197,7 @@ namespace SixLabors.ImageSharp.Tests
             }
         }
 
-        public class TestDecoder : IImageDecoder
+        public class TestDecoder : IImageDecoder, IImageInfoDetector
         {
             private TestFormat testFormat;
 
@@ -243,6 +243,12 @@ namespace SixLabors.ImageSharp.Tests
 
             public async Task<Image> DecodeAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
                 => await this.DecodeAsync<TestPixelForAgnosticDecode>(configuration, stream, cancellationToken);
+
+            public IImageInfo Identify(Configuration configuration, Stream stream) =>
+                this.IdentifyAsync(configuration, stream, default).GetAwaiter().GetResult();
+
+            public async Task<IImageInfo> IdentifyAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken)
+                => await this.DecodeImpl<Rgba32>(configuration, stream, cancellationToken);
         }
 
         public class TestEncoder : ImageSharp.Formats.IImageEncoder