Esempio n. 1
0
        public void ReadTagTest()
        {
            // Arrange
            double gammaUcr = 2.4, gammaBg = -2.2;
            string languageCode = "en";
            string countryCode  = "US";
            string expectedText = "read-tag";

            using (var ucr = ToneCurve.BuildGamma(null, gammaUcr))
                using (var bg = ToneCurve.BuildGamma(null, gammaBg))
                    using (var desc = MultiLocalizedUnicode.Create(null))
                    {
                        desc.SetASCII(languageCode, countryCode, expectedText);

                        var target = new UcrBg(ucr, bg, desc);
                        using (var profile = Profile.CreatePlaceholder(null))
                        {
                            profile.WriteTag(TagSignature.UcrBg, target);

                            // Act
                            var actual     = profile.ReadTag <UcrBg>(TagSignature.UcrBg);
                            var actualUcr  = actual.Ucr;
                            var actualBg   = actual.Bg;
                            var actualDesc = actual.Desc;

                            // Assert
                            Assert.IsNotNull(actualUcr);
                            Assert.IsNotNull(actualBg);
                            Assert.IsNotNull(actualDesc);
                            var actualText = actualDesc.GetASCII(languageCode, countryCode);
                            Assert.AreEqual(expectedText, actualText);
                        }
                    }
        }
Esempio n. 2
0
        public void FromHandleTest()
        {
            // Arrange
            int expected = 3;

            using (var profile = Profile.CreatePlaceholder(null))
            {
                using (var dict = Dict.Create(null))
                    using (var mlu = MultiLocalizedUnicode.Create(null, 0))
                    {
                        mlu.SetASCII("en", "GB", "Hello");

                        dict.Add("first", null, null, null);
                        dict.Add("second", "second-value", null, null);
                        dict.Add("third", "third-value", mlu, null);

                        profile.WriteTag(TagSignature.Meta, dict.Handle);
                    }

                // Act
                using (var roDict = Dict.FromHandle(profile.ReadTag(TagSignature.Meta)))
                {
                    // Assert
                    int actual = roDict.Count();
                    Assert.AreEqual(expected, actual);
                }
            }
        }
Esempio n. 3
0
        public void ConstructorTest()
        {
            // Arrange
            int type = 4;

            double[] parameters   = new double[] { 2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 0.04045 };
            double   gamma        = 2.2;
            uint     nItems       = 0;
            string   languageCode = "en";
            string   countryCode  = "US";
            string   text         = "constructor";

            using (var expectedUcr = ToneCurve.BuildParametric(null, type, parameters))
                using (var expectedBg = ToneCurve.BuildGamma(null, gamma))
                    using (var expectedDesc = MultiLocalizedUnicode.Create(null, nItems))
                    {
                        expectedDesc.SetASCII(languageCode, countryCode, text);

                        // Act
                        var target     = new UcrBg(expectedUcr, expectedBg, expectedDesc);
                        var actualUcr  = target.Ucr;
                        var actualBg   = target.Bg;
                        var actualDesc = target.Desc;

                        // Assert
                        Assert.AreSame(expectedUcr, actualUcr);
                        Assert.AreSame(expectedBg, actualBg);
                        Assert.AreSame(expectedDesc, actualDesc);
                    }
        }
Esempio n. 4
0
        public void ConstructorTest()
        {
            // Arrange
            int type = 4;

            double[] parameters   = new double[] { 2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 0.04045 };
            double   gamma        = 2.2;
            uint     nItems       = 0;
            string   languageCode = "en";
            string   countryCode  = "US";
            string   text         = "constructor";

            using (var context = Context.Create(IntPtr.Zero, IntPtr.Zero))
                using (var ucr = ToneCurve.BuildParametric(context, type, parameters))
                    using (var bg = ToneCurve.BuildGamma(context, gamma))
                        using (var desc = MultiLocalizedUnicode.Create(context, nItems))
                        {
                            desc.SetASCII(languageCode, countryCode, text);

                            var expectedUcr  = ucr.Handle;
                            var expectedBg   = bg.Handle;
                            var expectedDesc = desc.Handle;

                            // Act
                            var target     = new UcrBg(ucr, bg, desc);
                            var actualUcr  = target.Ucr;
                            var actualBg   = target.Bg;
                            var actualDesc = target.Desc;

                            // Assert
                            Assert.AreEqual(expectedUcr, actualUcr);
                            Assert.AreEqual(expectedBg, actualBg);
                            Assert.AreEqual(expectedDesc, actualDesc);
                        }
        }
Esempio n. 5
0
        public void PluginTagTest()
        {
            // Arrange
            const TagSignature SignaturelNET = (TagSignature)0x6C4E4554;  // 'lNET'

            PluginTag tag = new PluginTag
            {
                Base = new PluginBase
                {
                    Magic           = Cms.PluginMagicNumber,
                    ExpectedVersion = (uint)Cms.EncodedCMMVersion,    // >= 2.8
                    Type            = PluginType.Tag,
                    Next            = IntPtr.Zero
                },
                Signature  = SignaturelNET,
                Descriptor = new TagDescriptor
                {
                    ElemCount       = 1,
                    nSupportedTypes = 1,
                    SupportedTypes  = new TagTypeSignature[TagDescriptor.MAX_TYPES_IN_LCMS_PLUGIN],
                    Decider         = IntPtr.Zero
                }
            };

            tag.Descriptor.SupportedTypes[0] = TagTypeSignature.Text;

            string expected = "PluginTagTest";

            // Act
            int    rawsize = Marshal.SizeOf(tag);
            IntPtr plugin  = Marshal.AllocHGlobal(rawsize);

            Marshal.StructureToPtr(tag, plugin, false);
            try
            {
                using (var context = Context.Create(plugin, IntPtr.Zero))
                    using (var profile = Profile.CreatePlaceholder(context))
                    {
                        using (var mlu = MultiLocalizedUnicode.Create(context))
                        {
                            mlu.SetASCII(MultiLocalizedUnicode.NoLanguage, MultiLocalizedUnicode.NoCountry, expected);
                            bool written = profile.WriteTag(SignaturelNET, mlu);
                            Assert.IsTrue(written);
                        }

                        using (var mlu = profile.ReadTag <MultiLocalizedUnicode>(SignaturelNET))
                        {
                            var actual = mlu.GetASCII(MultiLocalizedUnicode.NoLanguage, MultiLocalizedUnicode.NoCountry);

                            // Assert
                            Assert.AreEqual(expected, actual);
                        }
                    }
            }
            finally
            {
                Marshal.DestroyStructure(plugin, typeof(PluginTag));
                Marshal.FreeHGlobal(plugin);
            }
        }
        //
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion

        MultiLocalizedUnicode Create(string enUS, string esES)
        {
            var mlu = MultiLocalizedUnicode.Create(null, 0);

            mlu.SetWide("en", "US", enUS);
            mlu.SetWide("es", "ES", esES);
            return(mlu);
        }
        public void GetWideTestNonExistent()
        {
            // Arrange
            using (var mlu = MultiLocalizedUnicode.Create(null))
            {
                // Act
                var actual = mlu.GetWide("en", "US");

                // Assert
                Assert.IsNull(actual);
            }
        }
        public void CreateTest()
        {
            // Arrange
            IntPtr plugin   = IntPtr.Zero;
            IntPtr userData = IntPtr.Zero;
            uint   nItems   = 3;

            // Act
            using (var context = Context.Create(plugin, userData))
                using (var mlu = MultiLocalizedUnicode.Create(context, nItems))
                {
                    // Assert
                    Assert.IsNotNull(mlu);
                }
        }
Esempio n. 9
0
        public void FromHandleTest()
        {
            // Arrange
            int type = 4;

            double[] parameters   = new double[] { 2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 0.04045 };
            double   gamma        = 2.2;
            uint     nItems       = 0;
            string   languageCode = "en";
            string   countryCode  = "US";
            string   expectedText = "from-handle";

            using (var context = Context.Create(IntPtr.Zero, IntPtr.Zero))
                using (var ucr = ToneCurve.BuildParametric(context, type, parameters))
                    using (var bg = ToneCurve.BuildGamma(context, gamma))
                        using (var desc = MultiLocalizedUnicode.Create(context, nItems))
                        {
                            desc.SetASCII(languageCode, countryCode, expectedText);

                            var notExpectedUcr  = IntPtr.Zero;
                            var notExpectedBg   = IntPtr.Zero;
                            var notExpectedDesc = IntPtr.Zero;

                            var target = new UcrBg(ucr, bg, desc);

                            using (var profile = Profile.CreatePlaceholder(null))
                            {
                                profile.WriteTag(TagSignature.UcrBg, target);
                                IntPtr handle = profile.ReadTag(TagSignature.UcrBg);

                                // Act
                                var actual     = UcrBg.FromHandle(handle);
                                var actualUcr  = actual.Ucr;
                                var actualBg   = actual.Bg;
                                var actualDesc = actual.Desc;

                                // Assert
                                Assert.AreNotEqual(notExpectedUcr, actualUcr);
                                Assert.AreNotEqual(notExpectedBg, actualBg);
                                Assert.AreNotEqual(notExpectedDesc, actualDesc);
                                var desc2      = MultiLocalizedUnicode.FromHandle(actualDesc);
                                var actualText = desc2.GetASCII(languageCode, countryCode);
                                Assert.AreEqual(expectedText, actualText);
                            }
                        }
        }
        public void GetTranslationTestNonExistent()
        {
            // Arrange
            string expectedLanguageCode = null;
            string expectedCountryCode  = null;

            using (var mlu = MultiLocalizedUnicode.Create(null))
            {
                // Act
                var actual = mlu.GetTranslation("en", "US",
                                                out string actualLanguageCode, out string actualCountryCode);

                // Assert
                Assert.IsFalse(actual);
                Assert.AreEqual(expectedLanguageCode, actualLanguageCode);
                Assert.AreEqual(expectedCountryCode, actualCountryCode);
            }
        }
        public void FromHandleTest()
        {
            // Arrange
            string expected = "sRGB IEC61966-2.1";

            using (MemoryStream ms = Save(".Resources.sRGB.icc"))
            {
                using (var profile = Profile.Open(ms.GetBuffer()))
                    using (var mlu = MultiLocalizedUnicode.FromHandle(profile.ReadTag(TagSignature.ProfileDescription)))
                    {
                        // Act
                        string actual = mlu.GetASCII(MultiLocalizedUnicode.NoLanguage, MultiLocalizedUnicode.NoCountry);

                        // Assert
                        Assert.AreEqual(expected, actual);
                    }
            }
        }
Esempio n. 12
0
        public void AddTest()
        {
            // Arrange
            string name  = "name";
            string value = "value";

            using (var dict = Dict.Create(null))
                using (var displayName = MultiLocalizedUnicode.Create(null, 0))
                {
                    displayName.SetWide("en", "US", "Hello");

                    // Act
                    bool added = dict.Add(name, value, displayName, null);

                    // Assert
                    Assert.IsTrue(added);
                }
        }
        public void TranslationsCodesTestIndexOutOfRange()
        {
            // Arrange
            uint   index = 3;
            string expectedLanguageCode = null;
            string expectedCountryCode  = null;

            using (var mlu = MultiLocalizedUnicode.Create(null))
            {
                // Act
                var actual = mlu.TranslationsCodes(index, out string actualLanguageCode, out string actualCountryCode);

                // Assert
                Assert.IsFalse(actual);
                Assert.AreEqual(expectedLanguageCode, actualLanguageCode);
                Assert.AreEqual(expectedCountryCode, actualCountryCode);
            }
        }
        public void TranslationsCodesTestNoLanguageNoCountry()
        {
            // Arrange
            var  expectedLanguageCode = MultiLocalizedUnicode.NoLanguage;
            var  expectedCountryCode  = MultiLocalizedUnicode.NoCountry;
            uint index = 0;

            using (var mlu = MultiLocalizedUnicode.Create(null))
            {
                mlu.SetASCII(expectedLanguageCode, expectedCountryCode, "TranslationsCodes");

                // Act
                var actual = mlu.TranslationsCodes(index, out string actualLanguageCode, out string actualCountryCode);

                // Assert
                Assert.AreEqual(expectedLanguageCode, actualLanguageCode);
                Assert.AreEqual(expectedCountryCode, actualCountryCode);
            }
        }
        public void SetWideTest()
        {
            // Arrange
            IntPtr plugin       = IntPtr.Zero;
            IntPtr userData     = IntPtr.Zero;
            uint   nItems       = 0;
            string languageCode = "en";
            string countryCode  = "US";

            // Act
            using (var context = Context.Create(plugin, userData))
                using (var mlu = MultiLocalizedUnicode.Create(context, nItems))
                {
                    bool set = mlu.SetWide(languageCode, countryCode, "SetWide");

                    // Assert
                    Assert.IsTrue(set);
                }
        }
        public void GetTranslationTestNoMatch()
        {
            // Arrange
            var expectedLanguageCode = "en";
            var expectedCountryCode  = "US";

            using (var mlu = MultiLocalizedUnicode.Create(null))
            {
                mlu.SetASCII(expectedLanguageCode, expectedCountryCode, "Apple");

                // Act
                var actual = mlu.GetTranslation("fr", "FR",
                                                out string actualLanguageCode, out string actualCountryCode);

                // Assert
                Assert.IsTrue(actual);
                Assert.AreEqual(expectedLanguageCode, actualLanguageCode);
                Assert.AreEqual(expectedCountryCode, actualCountryCode);
            }
        }
        public void DuplicateTest()
        {
            // Arrange
            IntPtr plugin   = IntPtr.Zero;
            IntPtr userData = IntPtr.Zero;
            uint   nItems   = 0;

            // Act
            using (var context = Context.Create(plugin, userData))
                using (var mlu = MultiLocalizedUnicode.Create(context, nItems))
                {
                    mlu.SetASCII(MultiLocalizedUnicode.NoLanguage, MultiLocalizedUnicode.NoCountry, "Duplicate");

                    using (var duplicate = mlu.Duplicate())
                    {
                        // Assert
                        Assert.IsNotNull(duplicate);
                    }
                }
        }
        public void TranslationsCountTest()
        {
            // Arrange
            IntPtr plugin       = IntPtr.Zero;
            IntPtr userData     = IntPtr.Zero;
            uint   nItems       = 0;
            string languageCode = "en";
            string countryCode  = "US";
            uint   notExpected  = 0;

            // Act
            using (var context = Context.Create(plugin, userData))
                using (var mlu = MultiLocalizedUnicode.Create(context, nItems))
                {
                    mlu.SetASCII(languageCode, countryCode, "TranslationsCount");
                    var actual = mlu.TranslationsCount;

                    // Assert
                    Assert.AreNotEqual(notExpected, actual);
                }
        }
        public void GetWideTest()
        {
            // Arrange
            IntPtr plugin       = IntPtr.Zero;
            IntPtr userData     = IntPtr.Zero;
            uint   nItems       = 0;
            string languageCode = "en";
            string countryCode  = "US";
            string expected     = "GetWide";

            // Act
            using (var context = Context.Create(plugin, userData))
                using (var mlu = MultiLocalizedUnicode.Create(context, nItems))
                {
                    mlu.SetWide(languageCode, countryCode, expected);
                    var actual = mlu.GetWide(languageCode, countryCode);

                    // Assert
                    Assert.AreEqual(expected, actual);
                }
        }
Esempio n. 20
0
        public void EnumerateTest()
        {
            // Arrange
            using (var dict = Dict.Create(null))
                using (var mlu = MultiLocalizedUnicode.Create(null, 0))
                {
                    mlu.SetASCII("en", "GB", "Hello");

                    dict.Add("first", null, null, null);
                    dict.Add("second", "second-value", null, null);
                    dict.Add("third", "third-value", mlu, null);
                    int expected = 3;

                    // Act
                    var actual = dict.Count();

                    var list = dict.ToArray();

                    // Assert
                    Assert.AreEqual(expected, actual);
                }
        }
        public void TranslationsCodeTest()
        {
            // Arrange
            IntPtr plugin               = IntPtr.Zero;
            IntPtr userData             = IntPtr.Zero;
            uint   nItems               = 0;
            string expectedLanguageCode = "en";
            string expectedCountryCode  = "US";
            uint   index = 0;

            // Act
            using (var context = Context.Create(plugin, userData))
                using (var mlu = MultiLocalizedUnicode.Create(context, nItems))
                {
                    mlu.SetASCII(expectedLanguageCode, expectedCountryCode, "TranslationsCount");
                    var actual = mlu.TranslationsCodes(index, out string actualLanguageCode, out string actualCountryCode);

                    // Assert
                    Assert.AreEqual(expectedLanguageCode, actualLanguageCode);
                    Assert.AreEqual(expectedCountryCode, actualCountryCode);
                }
        }
Esempio n. 22
0
        public void DescriptionSetTest()
        {
            // Arrange
            uint   nItems       = 3;
            string languageCode = "en";
            string countryCode  = "US";
            string expected     = "Description";

            using (var psd = ProfileSequenceDescriptor.Create(null, nItems))
                using (var mlu = MultiLocalizedUnicode.Create(null, 1))
                {
                    mlu.SetASCII(languageCode, countryCode, expected);
                    ProfileSequenceItem item = psd[2];

                    // Act
                    item.Description = mlu;

                    // Assert
                    string actual = item.Description.GetASCII(languageCode, countryCode);
                    Assert.AreEqual(expected, actual);
                }
        }
Esempio n. 23
0
        public void ManufacturerSetTest()
        {
            // Arrange
            uint   nItems       = 3;
            string languageCode = "en";
            string countryCode  = "US";
            string expected     = "Manufacturer";

            using (var psd = ProfileSequenceDescriptor.Create(null, nItems))
                using (var mlu = MultiLocalizedUnicode.Create(null, 1))
                {
                    mlu.SetASCII(languageCode, countryCode, expected);
                    ProfileSequenceItem item = psd[0];

                    // Act
                    item.Manufacturer = mlu;

                    // Assert
                    Assert.IsTrue(mlu.IsClosed);
                    string actual = item.Manufacturer.GetASCII(languageCode, countryCode);
                    Assert.AreEqual(expected, actual);
                }
        }
Esempio n. 24
0
        public void PluginTagWithDeciderTest()
        {
            // Arrange
            const TagSignature SignaturelNET = (TagSignature)0x6C4E4554;  // 'lNET'

            // ensure delegates are not garbage collected from managed code
            var decide = new DecideType(Decide);

            PluginTag tag = new PluginTag
            {
                Base = new PluginBase
                {
                    Magic           = Cms.PluginMagicNumber,
                    ExpectedVersion = (uint)Cms.EncodedCMMVersion,    // >= 2.8
                    Type            = PluginType.Tag,
                    Next            = IntPtr.Zero
                },
                Signature  = SignaturelNET,
                Descriptor = new TagDescriptor
                {
                    ElemCount       = 1,
                    nSupportedTypes = 1,
                    SupportedTypes  = new TagTypeSignature[TagDescriptor.MAX_TYPES_IN_LCMS_PLUGIN],
                    Decider         = Marshal.GetFunctionPointerForDelegate(decide)
                }
            };

            tag.Descriptor.SupportedTypes[0] = TagTypeSignature.Text;

            string expected = "PluginTagWithDeciderTest";

            // Act
            int    rawsize = Marshal.SizeOf(tag);
            IntPtr plugin  = Marshal.AllocHGlobal(rawsize);

            Marshal.StructureToPtr(tag, plugin, false);
            try
            {
                using (var context = Context.Create(plugin, IntPtr.Zero))
                    using (var profile = Profile.CreatePlaceholder(context))
                    {
                        using (var mlu = MultiLocalizedUnicode.Create(context))
                        {
                            mlu.SetASCII(MultiLocalizedUnicode.NoLanguage, MultiLocalizedUnicode.NoCountry, expected);
                            bool written = profile.WriteTag(SignaturelNET, mlu);
                            Assert.IsTrue(written);
                        }

                        using (var mlu = profile.ReadTag <MultiLocalizedUnicode>(SignaturelNET))
                        {
                            var actual = mlu.GetASCII(MultiLocalizedUnicode.NoLanguage, MultiLocalizedUnicode.NoCountry);

                            // Assert
                            Assert.AreEqual(expected, actual);
                        }
                    }
            }
            finally
            {
                Marshal.DestroyStructure(plugin, typeof(PluginTag));
                Marshal.FreeHGlobal(plugin);
            }

            TagTypeSignature Decide(double iccVersion, IntPtr data)
            {
                TestContext.WriteLine($"iccVersion: {iccVersion}, data: 0x{data:X}");

                using (var mlu = MultiLocalizedUnicode.FromHandle(data))
                {
                    var text = mlu.GetASCII(MultiLocalizedUnicode.NoLanguage, MultiLocalizedUnicode.NoCountry);
                    TestContext.WriteLine($"text: {text}");
                }

                return(TagTypeSignature.Text);
            }
        }