public void ShouldCreateMagickImage()
{
IMagickFactory factory = new MagickFactory();
var data = new byte[]
{
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0xf0, 0x3f,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0xf0, 0x3f,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
};
var settings = new PixelReadSettings(2, 1, StorageType.Double, PixelMapping.RGBA);
using (var stream = new MemoryStream(data))
{
using (IMagickImage image = factory.CreateImage(stream, settings))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(2, image.Width);
}
}
}
public void ShouldThrowExceptionWhenPixelReadSettingsIsNullAndFileNameIsSpecified()
{
ExceptionAssert.ThrowsArgumentNullException("settings", () =>
{
MagickFactory factory = new MagickFactory();
factory.CreateImage(Files.CirclePNG, (PixelReadSettings)null);
});
}
public void ShouldThrowExceptionWhenPixelStorageSettingsIsNullAndFileInfoIsSpecified()
{
ExceptionAssert.ThrowsArgumentNullException("pixelStorageSettings", () =>
{
MagickFactory factory = new MagickFactory();
factory.CreateImage(new FileInfo(Files.CirclePNG), (PixelStorageSettings)null);
});
}
public void ShouldThrowExceptionWhenPixelStorageSettingsIsNullAndByteArrayIsSpecified()
{
ExceptionAssert.ThrowsArgumentNullException("pixelStorageSettings", () =>
{
MagickFactory factory = new MagickFactory();
factory.CreateImage(new byte[] { 215 }, (PixelStorageSettings)null);
});
}
public void ShouldNotThrowExceptionWhenSettingsIsNull()
{
IMagickFactory factory = new MagickFactory();
using (var image = factory.CreateImage(File.ReadAllBytes(Files.CirclePNG), (MagickReadSettings)null))
{
}
}
public void ShouldThrowExceptionWhenPixelReadSettingsIsNullAndStreamIsSpecified()
{
ExceptionAssert.ThrowsArgumentNullException("settings", () =>
{
MagickFactory factory = new MagickFactory();
factory.CreateImage(new MemoryStream(new byte[] { 215 }), (PixelReadSettings)null);
});
}
public void ShouldThrowExceptionWhenCountIsNegative()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentException>("count", () =>
{
factory.CreateImage(new byte[] { 215 }, 0, -1);
});
}
public void ShouldThrowExceptionWhenSettingsIsNull()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentNullException>("settings", () =>
{
factory.CreateImage(new FileInfo(Files.CirclePNG), (PixelReadSettings)null);
});
}
public void ShouldThrowExceptionWhenFileInfoIsNull()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentNullException>("fileName", () =>
{
factory.CreateImage((string)null);
});
}
public void ShouldThrowExceptionWhenFileNameIsEmpty()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentException>("fileName", () =>
{
factory.CreateImage(string.Empty);
});
}
public void ShouldThrowExceptionWhenArrayIsEmpty()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentException>("data", () =>
{
factory.CreateImage(new byte[] { }, 0, 0);
});
}
public void ShouldThrowExceptionWhenStreamIsNull()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentNullException>("stream", () =>
{
factory.CreateImage((Stream)null);
});
}
public void ShouldThrowExceptionWhenStreamIsEmpty()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentException>("stream", () =>
{
factory.CreateImage(new MemoryStream());
});
}
public void ShouldThrowExceptionWhenArrayIsNull()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentNullException>("data", () =>
{
factory.CreateImage((byte[])null, 0, 0);
});
}
public void ShouldNotThrowExceptionWhenSettingsIsNull()
{
IMagickFactory factory = new MagickFactory();
using (IMagickImage image = factory.CreateImage(Files.CirclePNG, (MagickReadSettings)null))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
}
}
public void ShouldThrowExceptionWhenHeightIsNegative()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentException>("height", () =>
{
factory.CreateImage("xc:red", 1, -1);
});
}
public void ShouldThrowExceptionWhenHeightIsZero()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentException>("height", () =>
{
factory.CreateImage(MagickColors.Red, 1, 0);
});
}
public void ShouldThrowExceptionWhenWidthIsNegative()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentException>("width", () =>
{
factory.CreateImage("xc:red", -1, 1);
});
}
public void ShouldThrowExceptionWhenWidthIsZero()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentException>("width", () =>
{
factory.CreateImage(MagickColors.Red, 0, 1);
});
}
public void ShouldThrowExceptionWhenColorIsNull()
{
IMagickFactory factory = new MagickFactory();
ExceptionAssert.Throws <ArgumentNullException>("color", () =>
{
factory.CreateImage((MagickColor)null, 1, 1);
});
}
public void ShouldThrowExceptionWhenFileNameIsNull()
{
IMagickFactory factory = new MagickFactory();
var settings = new MagickReadSettings();
ExceptionAssert.Throws <ArgumentNullException>("fileName", () =>
{
factory.CreateImage((string)null, settings);
});
}
public void ShouldThrowExceptionWhenArrayIsEmpty()
{
IMagickFactory factory = new MagickFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentException>("data", () =>
{
factory.CreateImage(new byte[] { }, settings);
});
}
public void CreateImage_ReturnsMagickImage()
{
MagickFactory factory = new MagickFactory();
using (IMagickImage image = factory.CreateImage())
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(0, image.Width);
}
}
public void ShouldThrowExceptionWhenArrayIsNull()
{
IMagickFactory factory = new MagickFactory();
var settings = new MagickReadSettings();
ExceptionAssert.Throws <ArgumentNullException>("data", () =>
{
factory.CreateImage(null, 0, 0, settings);
});
}
public void ShouldThrowExceptionWhenStreamIsNull()
{
IMagickFactory factory = new MagickFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentNullException>("stream", () =>
{
factory.CreateImage((Stream)null, settings);
});
}
public void ShouldThrowExceptionWhenSettingsIsNull()
{
IMagickFactory factory = new MagickFactory();
var bytes = File.ReadAllBytes(Files.CirclePNG);
ExceptionAssert.Throws <ArgumentNullException>("settings", () =>
{
factory.CreateImage(bytes, 0, bytes.Length, (PixelReadSettings)null);
});
}
public void ShouldThrowExceptionWhenStreamIsEmptyAndPixelStorageSettingsIsSpecified()
{
ExceptionAssert.ThrowsArgumentException("stream", () =>
{
var pixelStorageSettings = new PixelStorageSettings();
MagickFactory factory = new MagickFactory();
factory.CreateImage(new MemoryStream(), pixelStorageSettings);
});
}
public void ShouldThrowExceptionWhenOffsetIsNegative()
{
IMagickFactory factory = new MagickFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentException>("offset", () =>
{
factory.CreateImage(new byte[] { 215 }, -1, 0, settings);
});
}
public void CreateImage_WithFileName_ReturnsMagickImage()
{
MagickFactory factory = new MagickFactory();
using (IMagickImage image = factory.CreateImage(Files.ImageMagickJPG))
{
Assert.IsInstanceOfType(image, typeof(MagickImage));
Assert.AreEqual(123, image.Width);
}
}
public void ShouldThrowExceptionWhenCountIsZero()
{
IMagickFactory factory = new MagickFactory();
var settings = new PixelReadSettings();
ExceptionAssert.Throws <ArgumentException>("count", () =>
{
factory.CreateImage(new byte[] { 215 }, 0, 0, settings);
});
}