Ejemplo n.º 1
0
 public void ShouldThrowExceptionWhenGeometryIsNull()
 {
     using (IMagickImage image = new MagickImage())
     {
         ExceptionAssert.ThrowsArgumentNullException("geometry", () =>
         {
             image.Evaluate(Channels.Red, null, EvaluateOperator.Set, 0.0);
         });
     }
 }
Ejemplo n.º 2
0
 public void ShouldThrowAnExceptionWhenDifferenceIsNull()
 {
     using (IMagickImage image = new MagickImage())
     {
         ExceptionAssert.ThrowsArgumentNullException("difference", () =>
         {
             image.Compare(image, new CompareSettings(), null);
         });
     }
 }
Ejemplo n.º 3
0
 public void ShouldThrowExceptionWhenArgumentsIsNull()
 {
     using (IMagickImage image = new MagickImage())
     {
         ExceptionAssert.ThrowsArgumentNullException("arguments", () =>
         {
             image.Evaluate(Channels.Red, EvaluateFunction.Arcsin, null);
         });
     }
 }
Ejemplo n.º 4
0
 public void ShouldThrowAnExceptionWhenImageIsNull()
 {
     using (IMagickImage image = new MagickImage())
     {
         ExceptionAssert.ThrowsArgumentNullException("image", () =>
         {
             image.Compare(null);
         });
     }
 }
Ejemplo n.º 5
0
 public void ShouldThrowExceptionWhenColorIsNull()
 {
     ExceptionAssert.ThrowsArgumentNullException("color", () =>
     {
         using (IMagickImage image = new MagickImage(MagickColors.White, 2, 2))
         {
             image.FloodFill((MagickColor)null, 0, 0);
         }
     });
 }
Ejemplo n.º 6
0
 public void ShouldThrowAnExceptionWhenImageIsNullAndSettingsAreNotNull()
 {
     using (IMagickImage image = new MagickImage())
     {
         using (IMagickImage diff = new MagickImage())
         {
             ExceptionAssert.ThrowsArgumentNullException("image", () =>
             {
                 image.Compare(null, new CompareSettings(), diff);
             });
         }
     }
 }
Ejemplo n.º 7
0
 public void ShouldThrowExceptionWhenMappingIsNull()
 {
     using (IMagickImage image = new MagickImage(Files.ImageMagickJPG))
     {
         using (IPixelCollection pixels = image.GetPixels())
         {
             ExceptionAssert.ThrowsArgumentNullException("mapping", () =>
             {
                 pixels.ToByteArray(null);
             });
         }
     }
 }
Ejemplo n.º 8
0
 public void ShouldThrowExceptionWhenPixelIsNull()
 {
     using (IMagickImage image = new MagickImage(Files.ImageMagickJPG))
     {
         using (IPixelCollection pixels = image.GetPixels())
         {
             ExceptionAssert.ThrowsArgumentNullException("pixel", () =>
             {
                 pixels.SetPixel((Pixel)null);
             });
         }
     }
 }
Ejemplo n.º 9
0
 public void ShouldThrowExceptionWhenByteArrayIsNull()
 {
     using (IMagickImage image = new MagickImage(Files.ImageMagickJPG))
     {
         using (IPixelCollection pixels = image.GetPixels())
         {
             ExceptionAssert.ThrowsArgumentNullException("values", () =>
             {
                 pixels.SetArea(10, 10, 1000, 1000, (byte[])null);
             });
         }
     }
 }
Ejemplo n.º 10
0
 public void ShouldThrowExceptionWhenGeometryIsNull()
 {
     using (IMagickImage image = new MagickImage(Files.RedPNG))
     {
         using (IPixelCollection pixels = image.GetPixels())
         {
             ExceptionAssert.ThrowsArgumentNullException("geometry", () =>
             {
                 pixels.GetArea(null);
             });
         }
     }
 }
Ejemplo n.º 11
0
 public void ShouldThrowAnExceptionWhenSettingsIsNull()
 {
     using (IMagickImage image = new MagickImage())
     {
         using (IMagickImage diff = new MagickImage())
         {
             ExceptionAssert.ThrowsArgumentNullException("settings", () =>
             {
                 image.Compare(image, null, diff);
             });
         }
     }
 }
Ejemplo n.º 12
0
 public void ShouldThrowExceptionWhenGeometryIsNull()
 {
     using (IMagickImage image = new MagickImage(Files.ImageMagickJPG))
     {
         using (IPixelCollection pixels = image.GetPixels())
         {
             ExceptionAssert.ThrowsArgumentNullException("geometry", () =>
             {
                 pixels.ToShortArray(null, "RGB");
             });
         }
     }
 }
Ejemplo n.º 13
0
 public void ShouldThrowExceptionWhenGeometryIsNullAndMappingIsEnum()
 {
     using (IMagickImage image = new MagickImage(Files.ImageMagickJPG))
     {
         using (IPixelCollection pixels = image.GetPixels())
         {
             ExceptionAssert.ThrowsArgumentNullException("geometry", () =>
             {
                 pixels.ToByteArray(null, PixelMapping.RGB);
             });
         }
     }
 }
Ejemplo n.º 14
0
 public void ShouldThrowAnExceptionWhenImageIsNullAndErrorMetricIsSpecified()
 {
     using (IMagickImage image = new MagickImage())
     {
         using (IMagickImage diff = new MagickImage())
         {
             ExceptionAssert.ThrowsArgumentNullException("image", () =>
             {
                 image.Compare(null, ErrorMetric.RootMeanSquared);
             });
         }
     }
 }
Ejemplo n.º 15
0
 public void ShouldThrowExceptionWhenGeometryIsSpecifiedAndMappingIsNull()
 {
     using (IMagickImage image = new MagickImage(Files.ImageMagickJPG))
     {
         using (IPixelCollection pixels = image.GetPixels())
         {
             ExceptionAssert.ThrowsArgumentNullException("mapping", () =>
             {
                 pixels.ToShortArray(new MagickGeometry(1, 2, 3, 4), null);
             });
         }
     }
 }
Ejemplo n.º 16
0
 public void ShouldThrowExceptionWhenByteArrayIsSpecifiedAndGeometryIsNull()
 {
     using (IMagickImage image = new MagickImage(Files.ImageMagickJPG))
     {
         using (IPixelCollection pixels = image.GetPixels())
         {
             ExceptionAssert.ThrowsArgumentNullException("geometry", () =>
             {
                 pixels.SetArea(null, new byte[] { 0 });
             });
         }
     }
 }
Ejemplo n.º 17
0
        public void Test_Constructor()
        {
            PointD point = default(PointD);

            Assert.AreEqual(0.0, point.X);
            Assert.AreEqual(0.0, point.Y);

            point = new PointD(5);
            Assert.AreEqual(5.0, point.X);
            Assert.AreEqual(5.0, point.Y);

            point = new PointD(5, 10);
            Assert.AreEqual(5.0, point.X);
            Assert.AreEqual(10.0, point.Y);

            ExceptionAssert.ThrowsArgumentNullException("value", () =>
            {
                new PointD(null);
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new PointD(string.Empty);
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new PointD("1.0x");
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new PointD("x1.0");
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new PointD("ax1.0");
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new PointD("1.0xb");
            });

            point = new PointD("1.0x2.5");
            Assert.AreEqual(1.0, point.X);
            Assert.AreEqual(2.5, point.Y);
            Assert.AreEqual("1x2.5", point.ToString());
        }
Ejemplo n.º 18
0
        public void Test_SetEncoding()
        {
            using (IMagickImage image = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
            {
                IptcProfile profile = image.GetIptcProfile();
                TestProfileValues(profile);

                ExceptionAssert.ThrowsArgumentNullException("encoding", () =>
                {
                    profile.SetEncoding(null);
                });

                profile.SetEncoding(Encoding.UTF8);
                Assert.AreEqual(Encoding.UTF8, profile.Values.First().Encoding);
            }
        }
Ejemplo n.º 19
0
        public void Test_Execute_Variables()
        {
            MagickScript script = new MagickScript(Files.Scripts.Variables);

            string[] names = script.Variables.Names.ToArray();
            Assert.AreEqual(4, names.Length);
            Assert.AreEqual("width", names[0]);
            Assert.AreEqual("height", names[1]);
            Assert.AreEqual("color", names[2]);
            Assert.AreEqual("fillColor", names[3]);

            using (IMagickImage image = new MagickImage(Files.MagickNETIconPNG))
            {
                ExceptionAssert.ThrowsArgumentNullException("attribute", () =>
                {
                    script.Execute(image);
                });

                script.Variables["width"] = "test";

                ExceptionAssert.Throws <FormatException>(() =>
                {
                    script.Execute(image);
                });

                script.Variables.Set("width", 100);

                ExceptionAssert.ThrowsArgumentNullException("attribute", () =>
                {
                    script.Execute(image);
                });

                script.Variables["height"] = "100";
                Assert.AreEqual("100", script.Variables.Get("height"));
                script.Variables["color"]     = MagickColors.Yellow;
                script.Variables["fillColor"] = MagickColors.Red;

                script.Execute(image);

                Assert.AreEqual(100, image.Width);
                Assert.AreEqual(100, image.Height);
                ColorAssert.AreEqual(MagickColors.Yellow, image, 0, 0);

                ColorAssert.AreEqual(MagickColors.Yellow, image.Settings.StrokeColor);
                ColorAssert.AreEqual(MagickColors.Red, image.Settings.FillColor);
            }
        }
Ejemplo n.º 20
0
        public void Test_Constructor()
        {
            ExceptionAssert.ThrowsArgumentNullException("color", () =>
            {
                new MagickColor((string)null);
            });

            ExceptionAssert.ThrowsArgumentException("color", () =>
            {
                new MagickColor("FFFFFF");
            });

            ExceptionAssert.ThrowsArgumentException("color", () =>
            {
                new MagickColor("#FFFFF");
            });

            ExceptionAssert.ThrowsArgumentException("color", () =>
            {
                new MagickColor("#GGFFF");
            });

            ExceptionAssert.ThrowsArgumentException("color", () =>
            {
                new MagickColor("#FGF");
            });

            ExceptionAssert.ThrowsArgumentException("color", () =>
            {
                new MagickColor("#FFFG000000000000");
            });

            TestColor("#FF", Quantum.Max, Quantum.Max, Quantum.Max, false);
            TestColor("#F00", Quantum.Max, 0, 0, false);
            TestColor("#0F00", 0, Quantum.Max, 0, true);
            TestColor("#0000FF", 0, 0, Quantum.Max, false);
            TestColor("#FF00FF00", Quantum.Max, 0, Quantum.Max, true);

            TestColor("#0000FFFF0000", 0, Quantum.Max, 0, false);
            TestColor("#000080000000", 0, (QuantumType)((Quantum.Max / 2.0) + 0.5), 0, false);
            TestColor("#FFFf000000000000", Quantum.Max, 0, 0, true);

            float half = Quantum.Max * 0.5f;

            TestColor("gray(50%) ", half, half, half, false, 1);
            TestColor("rgba(100%, 0%, 0%, 0.0)", Quantum.Max, 0, 0, true);
        }
Ejemplo n.º 21
0
        public void Test_Constructor()
        {
            ExceptionAssert.ThrowsArgumentNullException("fileName", () =>
            {
                new MagickScript((string)null);
            });

            ExceptionAssert.ThrowsArgumentNullException("stream", () =>
            {
                new MagickScript((Stream)null);
            });

            ExceptionAssert.Throws <DirectoryNotFoundException>(() =>
            {
                new MagickScript(Files.Missing);
            });
        }
Ejemplo n.º 22
0
        public void Test_Image_Exceptions()
        {
            ExceptionAssert.ThrowsArgumentException("readSettings", () =>
            {
                MagickReadSettings settings       = CreateSettings();
                settings.PixelStorage.StorageType = StorageType.Undefined;
                new MagickImage(Files.SnakewarePNG, settings);
            });

            ExceptionAssert.ThrowsArgumentNullException("readSettings", () =>
            {
                MagickReadSettings settings   = CreateSettings();
                settings.PixelStorage.Mapping = null;
                new MagickImage(Files.SnakewarePNG, settings);
            });

            ExceptionAssert.ThrowsArgumentException("readSettings", () =>
            {
                MagickReadSettings settings   = CreateSettings();
                settings.PixelStorage.Mapping = string.Empty;
                new MagickImage(Files.SnakewarePNG, settings);
            });

            ExceptionAssert.ThrowsArgumentNullException("readSettings", () =>
            {
                MagickReadSettings settings = CreateSettings();
                settings.Width = null;
                new MagickImage(Files.SnakewarePNG, settings);
            });

            ExceptionAssert.ThrowsArgumentNullException("readSettings", () =>
            {
                MagickReadSettings settings = CreateSettings();
                settings.Height             = null;
                new MagickImage(Files.SnakewarePNG, settings);
            });

            ExceptionAssert.ThrowsArgumentException("data", () =>
            {
                MagickReadSettings settings = CreateSettings();
                byte[] data = new byte[] { 0 };
                new MagickImage(data, settings);
            });
        }
Ejemplo n.º 23
0
        public void Test_Constructor()
        {
            ExceptionAssert.ThrowsArgumentNullException("hash", () =>
            {
                new PerceptualHash(null);
            });

            ExceptionAssert.ThrowsArgumentException("hash", () =>
            {
                new PerceptualHash(string.Empty);
            });

            ExceptionAssert.ThrowsArgumentException("hash", () =>
            {
                new PerceptualHash("a0df");
            });

            ExceptionAssert.ThrowsArgumentException("hash", () =>
            {
                new PerceptualHash("H00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
            });
        }
Ejemplo n.º 24
0
        public void Test_Path_Exceptions()
        {
            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new PathArcAbs();
            });

            ExceptionAssert.ThrowsArgumentNullException("coordinates", () =>
            {
                new PathArcAbs(null);
            });

            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new PathArcAbs(new PathArc[] { });
            });

            ExceptionAssert.ThrowsArgumentNullException("coordinates", () =>
            {
                new PathArcAbs(new PathArc[] { null });
            });

            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new PathArcRel();
            });

            ExceptionAssert.ThrowsArgumentNullException("coordinates", () =>
            {
                new PathArcRel(null);
            });

            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new PathArcRel(new PathArc[] { });
            });

            ExceptionAssert.ThrowsArgumentNullException("coordinates", () =>
            {
                new PathArcRel(new PathArc[] { null });
            });

            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new PathLineToAbs();
            });

            ExceptionAssert.ThrowsArgumentNullException("coordinates", () =>
            {
                new PathLineToAbs(null);
            });

            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new PathLineToAbs(new PointD[] { });
            });

            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new PathLineToRel();
            });

            ExceptionAssert.ThrowsArgumentNullException("coordinates", () =>
            {
                new PathLineToRel(null);
            });

            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new PathLineToRel(new PointD[] { });
            });
        }
Ejemplo n.º 25
0
        public void Test_Constructor()
        {
            Density density = new Density(5);

            Assert.AreEqual(5.0, density.X);
            Assert.AreEqual(5.0, density.Y);
            Assert.AreEqual(DensityUnit.PixelsPerInch, density.Units);

            density = new Density(8.5, DensityUnit.PixelsPerCentimeter);
            Assert.AreEqual(8.5, density.X);
            Assert.AreEqual(8.5, density.Y);
            Assert.AreEqual(DensityUnit.PixelsPerCentimeter, density.Units);

            density = new Density(2, 3);
            Assert.AreEqual(2.0, density.X);
            Assert.AreEqual(3.0, density.Y);
            Assert.AreEqual(DensityUnit.PixelsPerInch, density.Units);

            density = new Density(2.2, 3.3, DensityUnit.Undefined);
            Assert.AreEqual(2.2, density.X);
            Assert.AreEqual(3.3, density.Y);
            Assert.AreEqual(DensityUnit.Undefined, density.Units);

            ExceptionAssert.ThrowsArgumentNullException("value", () =>
            {
                new Density(null);
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new Density(string.Empty);
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new Density("1.0x");
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new Density("x1.0");
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new Density("ax1.0");
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new Density("1.0xb");
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new Density("1.0x6 magick");
            });

            density = new Density("1.0x2.5");
            Assert.AreEqual(1.0, density.X);
            Assert.AreEqual(2.5, density.Y);
            Assert.AreEqual(DensityUnit.Undefined, density.Units);
            Assert.AreEqual("1x2.5", density.ToString());

            density = new Density("2.5x1.0 cm");
            Assert.AreEqual(2.5, density.X);
            Assert.AreEqual(1.0, density.Y);
            Assert.AreEqual(DensityUnit.PixelsPerCentimeter, density.Units);
            Assert.AreEqual("2.5x1 cm", density.ToString());

            density = new Density("2.5x1.0 inch");
            Assert.AreEqual(2.5, density.X);
            Assert.AreEqual(1.0, density.Y);
            Assert.AreEqual(DensityUnit.PixelsPerInch, density.Units);
            Assert.AreEqual("2.5x1 inch", density.ToString());
        }
Ejemplo n.º 26
0
 public void ShouldThrowExceptionWhenValueIsNull()
 {
     ExceptionAssert.ThrowsArgumentNullException("value", () => { new Density(null); });
 }
Ejemplo n.º 27
0
 public void ShouldThrowExceptionWhenValueIsNull()
 {
     ExceptionAssert.ThrowsArgumentNullException("value", () => new MagickGeometry(null));
 }
Ejemplo n.º 28
0
        public void Test_Drawables_Exceptions()
        {
            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new DrawableBezier();
            });

            ExceptionAssert.ThrowsArgumentNullException("coordinates", () =>
            {
                new DrawableBezier(null);
            });

            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new DrawableBezier(new PointD[] { });
            });

            ExceptionAssert.ThrowsArgumentNullException("clipPath", () =>
            {
                new DrawableClipPath(null);
            });

            ExceptionAssert.ThrowsArgumentException("clipPath", () =>
            {
                new DrawableClipPath(string.Empty);
            });

            ExceptionAssert.ThrowsArgumentNullException("offset", () =>
            {
                new DrawableComposite(null, new MagickImage(Files.Builtin.Logo));
            });

            ExceptionAssert.ThrowsArgumentNullException("image", () =>
            {
                new DrawableComposite(new MagickGeometry(), null);
            });

            ExceptionAssert.ThrowsArgumentNullException("color", () =>
            {
                new DrawableFillColor(null);
            });

            ExceptionAssert.ThrowsArgumentNullException("family", () =>
            {
                new DrawableFont(null);
            });

            ExceptionAssert.ThrowsArgumentException("family", () =>
            {
                new DrawableFont(string.Empty);
            });

            ExceptionAssert.Throws <MagickDrawErrorException>(() =>
            {
                using (IMagickImage image = new MagickImage(Files.Builtin.Wizard))
                {
                    image.Draw(new DrawableFillPatternUrl("#fail"));
                }
            });

            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new DrawablePolygon(new PointD[] { new PointD(0, 0) });
            });

            ExceptionAssert.ThrowsArgumentException("coordinates", () =>
            {
                new DrawablePolyline(new PointD[] { new PointD(0, 0), new PointD(0, 0) });
            });

            ExceptionAssert.ThrowsArgumentNullException("color", () =>
            {
                new DrawableStrokeColor(null);
            });

            ExceptionAssert.ThrowsArgumentNullException("value", () =>
            {
                new DrawableText(0, 0, null);
            });

            ExceptionAssert.ThrowsArgumentException("value", () =>
            {
                new DrawableText(0, 0, string.Empty);
            });

            ExceptionAssert.ThrowsArgumentNullException("encoding", () =>
            {
                new DrawableTextEncoding(null);
            });
        }
Ejemplo n.º 29
0
        public void Test_SetValue()
        {
            using (MemoryStream memStream = new MemoryStream())
            {
                string credit = null;
                for (int i = 0; i < 255; i++)
                {
                    credit += i.ToString() + ".";
                }

                using (IMagickImage image = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
                {
                    IptcProfile profile = image.GetIptcProfile();
                    TestProfileValues(profile);

                    IptcValue value = profile.GetValue(IptcTag.Title);
                    TestValue(value, "Communications");

                    profile.SetValue(IptcTag.Title, "Magick.NET Title");
                    TestValue(value, "Magick.NET Title");

                    value = profile.GetValue(IptcTag.Title);
                    TestValue(value, "Magick.NET Title");

                    value = profile.Values.FirstOrDefault(val => val.Tag == IptcTag.ReferenceNumber);
                    Assert.IsNull(value);

                    profile.SetValue(IptcTag.ReferenceNumber, "Magick.NET ReferenceNümber");

                    value = profile.GetValue(IptcTag.ReferenceNumber);
                    TestValue(value, "Magick.NET ReferenceNümber");

                    profile.SetValue(IptcTag.Credit, credit);

                    value = profile.GetValue(IptcTag.Credit);
                    TestValue(value, credit);

                    // Remove the 8bim profile so we can overwrite the iptc profile.
                    image.RemoveProfile("8bim");
                    image.AddProfile(profile);

                    image.Write(memStream);
                    memStream.Position = 0;
                }

                using (IMagickImage image = new MagickImage(memStream))
                {
                    IptcProfile profile = image.GetIptcProfile();
                    TestProfileValues(profile, 19);

                    IptcValue value = profile.GetValue(IptcTag.Title);
                    TestValue(value, "Magick.NET Title");

                    value = profile.GetValue(IptcTag.ReferenceNumber);
                    TestValue(value, "Magick.NET ReferenceNümber");

                    value = profile.GetValue(IptcTag.Credit);
                    TestValue(value, credit);

                    ExceptionAssert.ThrowsArgumentNullException("encoding", () =>
                    {
                        profile.SetValue(IptcTag.Caption, null, "Test");
                    });

                    profile.SetValue(IptcTag.Caption, "Test");
                    value = profile.Values.ElementAt(1);
                    Assert.AreEqual("Test", value.Value);

                    profile.SetValue(IptcTag.Caption, Encoding.UTF32, "Test");
                    Assert.AreEqual(Encoding.UTF32, value.Encoding);
                    Assert.AreEqual("Test", value.Value);

                    Assert.IsTrue(profile.RemoveValue(IptcTag.Caption));
                    Assert.IsFalse(profile.RemoveValue(IptcTag.Caption));
                    Assert.IsNull(profile.GetValue(IptcTag.Caption));
                }
            }
        }