plist-cil/plist-cil.test/ValuePreprocessorTests.cs

using System;
using System.Linq;
using Claunia.PropertyList;
using Xunit;

namespace plistcil.test
{
    public static class ValuePreprocessorTests
    {
        // lock tests to make sure temporarily added / replaced preprocessors don't interfere with the other tests in this suite
        private static readonly object _testLock = new();

        [Fact]
        public static void TestPassiveDefaultPreprocessorsRegistered()
        {
            Assert.Equal(true, ValuePreprocessor.Preprocess(true, ValuePreprocessor.Type.BOOL));
            Assert.Equal(false, ValuePreprocessor.Preprocess(false, ValuePreprocessor.Type.BOOL));
            Assert.Equal("true", ValuePreprocessor.Preprocess("true", ValuePreprocessor.Type.BOOL));
            Assert.Equal("42", ValuePreprocessor.Preprocess("42", ValuePreprocessor.Type.INTEGER));
            Assert.Equal("3.14159", ValuePreprocessor.Preprocess("3.14159", ValuePreprocessor.Type.FLOATING_POINT));
            Assert.Equal("2.71828", ValuePreprocessor.Preprocess("2.71828", ValuePreprocessor.Type.UNDEFINED_NUMBER));
            Assert.Equal("TestString", ValuePreprocessor.Preprocess("TestString", ValuePreprocessor.Type.STRING));
            Assert.Equal("TestData", ValuePreprocessor.Preprocess("TestData", ValuePreprocessor.Type.DATA));
            byte[] value = [0x1, 0x2, 0x4, 0x8];
            Assert.Equal(value, ValuePreprocessor.Preprocess(value, ValuePreprocessor.Type.DATA));
            Assert.Equal("01.02.1903", ValuePreprocessor.Preprocess("01.02.1903", ValuePreprocessor.Type.DATE));
            Assert.Equal(23.0, ValuePreprocessor.Preprocess(23.0, ValuePreprocessor.Type.DATE));
        }

        [Fact]
        public static void TestRegisterPreprocessor()
        {
            lock(_testLock)
            {
                Func<string, string> examplePreprocessor = value => new string(value.Reverse().ToArray());
                string               testString          = "TestString";
                string               expected            = "gnirtStseT";

                var testType = (ValuePreprocessor.Type)42;

                ValuePreprocessor.Set(examplePreprocessor, testType);
                string actual = ValuePreprocessor.Preprocess(testString, testType);

                Assert.Equal(actual, expected);

                ValuePreprocessor.Unset<string>(testType);
            }
        }

        [Fact]
        public static void TestRegisteredPreprocessorSelection1()
        {
            lock(_testLock)
            {
                Func<short, short> examplePreprocessor = value => (short)(value - 1);
                short              testShort           = 42;
                string             testString          = "TestString";

                var testType = (ValuePreprocessor.Type)42;

                // correct value type, differing data type
                ValuePreprocessor.Set(examplePreprocessor, testType);
                ValuePreprocessor.Set(ValuePreprocessor.GetDefault<string>(), testType);

                string actual1 = ValuePreprocessor.Preprocess(testString, testType);
                short  actual2 = ValuePreprocessor.Preprocess(testShort, testType);

                // assert unchanged, since the selected preprocessor != tested preprocessor
                Assert.Equal(actual1, testString);
                Assert.NotEqual(actual2, testShort);

                ValuePreprocessor.Remove<short>(testType);
                ValuePreprocessor.Remove<string>(testType);
            }
        }

        [Fact]
        public static void TestRegisteredPreprocessorSelection2()
        {
            lock(_testLock)
            {
                Func<string, string> examplePreprocessor = value => new string(value.Reverse().ToArray());
                byte[]               testByteArray       = [0x42,];
                string               testString          = "TestString";

                var testType = (ValuePreprocessor.Type)42;

                // correct value type, differing data type
                ValuePreprocessor.Set(examplePreprocessor, testType);
                ValuePreprocessor.Set(ValuePreprocessor.GetDefault<byte[]>(), testType);

                string actual1 = ValuePreprocessor.Preprocess(testString, testType);
                byte[] actual2 = ValuePreprocessor.Preprocess(testByteArray, testType);

                Assert.NotEqual(actual1, testString);

                // assert unchanged, since the selected preprocessor != tested preprocessor
                Assert.Equal(actual2, testByteArray);

                ValuePreprocessor.Unset<string>(testType);
                ValuePreprocessor.Remove<byte[]>(testType);
            }
        }

        [Fact]
        public static void TestUnregisteredPreprocessorThrows()
        {
            byte[] testArray = [0x1, 0x2, 0x4, 0x8];

            // there's no registered preprocessor for byte array arguments for STRING
            Assert.Throws<ArgumentException>(() => ValuePreprocessor.Preprocess(testArray, ValuePreprocessor.Type.STRING));
        }
    }
}