public void ShouldThrowExceptionWhenStreamIsEmpty()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
Assert.Throws <ArgumentException>("stream", () =>
{
factory.Create(new MemoryStream(), settings);
});
}
public void ShouldThrowExceptionWhenSettingsIsNull()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
Assert.Throws <ArgumentNullException>("settings", () =>
{
factory.Create(Files.CirclePNG, (PixelReadSettings)null);
});
}
public void ShouldThrowExceptionWhenStreamIsNull()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
Assert.Throws <ArgumentNullException>("stream", () =>
{
factory.Create((Stream)null, settings);
});
}
public void ShouldThrowExceptionWhenArrayIsNull()
{
IMagickFactory factory = new MagickFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentNullException>("data", () =>
{
factory.CreateImage((byte[])null, settings);
});
}
public void ShouldThrowExceptionWhenFileNameIsEmpty()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
Assert.Throws <ArgumentException>("fileName", () =>
{
factory.Create(string.Empty, settings);
});
}
public void ShouldThrowExceptionWhenOffsetIsNegative()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
Assert.Throws <ArgumentException>("offset", () =>
{
factory.Create(new byte[] { 215 }, -1, 0, settings);
});
}
public void ShouldThrowExceptionWhenCountIsZero()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
Assert.Throws <ArgumentException>("count", () =>
{
factory.Create(new byte[] { 215 }, 0, 0, settings);
});
}
public void ShouldThrowExceptionWhenFileInfoIsNull()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentNullException>("file", () =>
{
factory.Create((FileInfo)null, settings);
});
}
public void ShouldThrowExceptionWhenFileNameIsNull()
{
IMagickFactory factory = new MagickFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentNullException>("fileName", () =>
{
factory.CreateImage((string)null, settings);
});
}
public void ShouldThrowExceptionWhenStreamIsEmptyAndPixelReadSettingsIsSpecified()
{
ExceptionAssert.ThrowsArgumentException("stream", () =>
{
var settings = new PixelReadSettings();
MagickFactory factory = new MagickFactory();
factory.CreateImage(new MemoryStream(), settings);
});
}
public void ShouldThrowExceptionWhenFileInfoIsNullAndPixelReadSettingsIsSpecified()
{
ExceptionAssert.ThrowsArgumentNullException("file", () =>
{
var settings = new PixelReadSettings();
MagickFactory factory = new MagickFactory();
factory.CreateImage((FileInfo)null, settings);
});
}
public void ShouldThrowExceptionWhenByteArrayIsEmptyAndPixelReadSettingsIsSpecified()
{
ExceptionAssert.ThrowsArgumentException("data", () =>
{
var settings = new PixelReadSettings();
MagickFactory factory = new MagickFactory();
factory.CreateImage(new byte[] { }, settings);
});
}
public void ShouldThrowExceptionWhenHeightIsNull()
{
ExceptionAssert.Throws <ArgumentException>("settings", () =>
{
var settings = new PixelReadSettings(1, 1, StorageType.Char, "RGBA");
settings.ReadSettings.Height = null;
new MagickImage(Files.CirclePNG, settings);
}, "Height");
}
public void ShouldThrowExceptionWhenArrayIsEmpty()
{
var factory = new MagickImageFactory();
var settings = new PixelReadSettings();
Assert.Throws <ArgumentException>("data", () =>
{
factory.Create(new byte[] { }, settings);
});
}
public void ShouldThrowExceptionWhenCountIsNegative()
{
IMagickFactory factory = new MagickFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentException>("count", () =>
{
factory.CreateImage(new byte[] { 215 }, 0, -1, settings);
});
}
public void ShouldThrowExceptionWhenMappingIsEmpty()
{
ExceptionAssert.ThrowsArgumentException("settings", () =>
{
var settings = new PixelReadSettings(1, 1, StorageType.Char, string.Empty);
MagickFactory factory = new MagickFactory();
factory.CreateImage(Files.CirclePNG, settings);
}, "mapping");
}
public void ShouldSetTheMappingCorrectly()
{
var settings = new PixelReadSettings(1, 2, StorageType.Int64, PixelMapping.CMYK);
Assert.NotNull(settings.ReadSettings);
Assert.Equal(1, settings.ReadSettings.Width);
Assert.Equal(2, settings.ReadSettings.Height);
Assert.Equal(StorageType.Int64, settings.StorageType);
Assert.Equal("CMYK", settings.Mapping);
}
public void ShouldSetTheProperties()
{
var settings = new PixelReadSettings(3, 4, StorageType.Quantum, "CMY");
Assert.NotNull(settings.ReadSettings);
Assert.Equal(3, settings.ReadSettings.Width);
Assert.Equal(4, settings.ReadSettings.Height);
Assert.Equal(StorageType.Quantum, settings.StorageType);
Assert.Equal("CMY", settings.Mapping);
}
public void ShouldThrowExceptionWhenWidthIsNull()
{
ExceptionAssert.ThrowsArgumentException("settings", () =>
{
var settings = new PixelReadSettings(1, 1, StorageType.Char, "RGBA");
settings.ReadSettings.Width = null;
MagickFactory factory = new MagickFactory();
factory.CreateImage(Files.CirclePNG, settings);
}, "Width");
}
public async Task ShouldThrowExceptionWhenMappingIsNull()
{
var settings = new PixelReadSettings(1, 1, StorageType.Char, null);
using (var image = new MagickImage())
{
var exception = await Assert.ThrowsAsync <ArgumentException>("settings", () => image.ReadPixelsAsync(Files.CirclePNG, settings));
Assert.Contains("mapping", exception.Message);
}
}
public void ShouldSetTheProperties()
{
var readSettings = new MagickReadSettings();
var pixelReadSettings = new PixelReadSettings();
var eventArgs = new ScriptReadEventArgs("test", readSettings, pixelReadSettings);
Assert.AreEqual("test", eventArgs.Id);
Assert.AreEqual(readSettings, eventArgs.ReadSettings);
Assert.AreEqual(pixelReadSettings, eventArgs.PixelReadSettings);
}
public void ShouldThrowExceptionWhenMappingIsEmpty()
{
var exception = Assert.Throws <ArgumentException>("settings", () =>
{
var settings = new PixelReadSettings(1, 1, StorageType.Char, string.Empty);
new MagickImage(Files.CirclePNG, settings);
});
Assert.Contains("mapping", exception.Message);
}
public void ShouldThrowExceptionWhenWidthIsNull()
{
var exception = Assert.Throws <ArgumentException>("settings", () =>
{
var settings = new PixelReadSettings(1, 1, StorageType.Char, "RGBA");
settings.ReadSettings.Width = null;
new MagickImage(Files.CirclePNG, settings);
});
Assert.Contains("Width", exception.Message);
}
public void ShouldThrowExceptionWhenStreamIsEmpty()
{
var settings = new PixelReadSettings();
using (IMagickImage image = new MagickImage())
{
ExceptionAssert.Throws <ArgumentException>("stream", () =>
{
image.ReadPixels(new MemoryStream(), settings);
});
}
}
public void ShouldThrowExceptionWhenArrayIsEmpty()
{
var settings = new PixelReadSettings();
using (IMagickImage image = new MagickImage())
{
ExceptionAssert.Throws <ArgumentException>("data", () =>
{
image.ReadPixels(new byte[] { }, settings);
});
}
}
public void ShouldThrowExceptionWhenStreamIsNull()
{
var settings = new PixelReadSettings();
using (IMagickImage image = new MagickImage())
{
ExceptionAssert.Throws <ArgumentNullException>("stream", () =>
{
image.ReadPixels((Stream)null, settings);
});
}
}
public void ShouldThrowExceptionWhenMappingIsEmpty()
{
var settings = new PixelReadSettings(1, 1, StorageType.Char, string.Empty);
using (IMagickImage image = new MagickImage())
{
ExceptionAssert.Throws <ArgumentException>("settings", () =>
{
image.ReadPixels(Files.CirclePNG, settings);
}, "mapping");
}
}
public void ShouldThrowExceptionWhenFileNameIsEmpty()
{
var settings = new PixelReadSettings();
using (IMagickImage image = new MagickImage())
{
ExceptionAssert.Throws <ArgumentException>("fileName", () =>
{
image.ReadPixels(string.Empty, settings);
});
}
}
public void ShouldThrowExceptionWhenCountIsNegative()
{
var settings = new PixelReadSettings();
using (IMagickImage image = new MagickImage())
{
ExceptionAssert.Throws <ArgumentException>("count", () =>
{
image.ReadPixels(new byte[] { 215 }, 0, -1, settings);
});
}
}
public void ShouldThrowExceptionWhenArrayIsNull()
{
var settings = new PixelReadSettings();
using (var image = new MagickImage())
{
Assert.Throws <ArgumentNullException>("data", () =>
{
image.ReadPixels((byte[])null, settings);
});
}
}
