예제 #1
0
        public void AddByCodeOnlyTest()
        {
            // code already exists
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name)
                {
                    2.0
                };

                ExceptionAssert.Throw(
                    () => { target.Add(2.0); },
                    expectedType: typeof(InvalidOperationException),
                    expectedMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_CAT_ALREADY_EXISTS_IN_VARIABLE_LIST"));
            }

            // target is read only
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name);

                target.SetAsReadOnly();

                ExceptionAssert.Throw(
                    () => { target.Add(3.0); },
                    expectedType: typeof(InvalidOperationException),
                    expectedMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_CAT_VARIABLE_IS_READONLY"));
            }

            // Valid input
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name);

                double   code;
                Category category0, category1;

                code = 1.0;
                target.Add(code);
                category0 = new Category(code);

                code = 2.0;
                target.Add(code);
                category1 = new Category(code);

                CategoricalVariableAssert.IsStateAsExpected(
                    target,
                    name,
                    expectedCategories: new List <Category>(2)
                {
                    category0,
                    category1
                },
                    expectedReadOnlyFlag: false);
            }
        }
예제 #2
0
        public void SetAsReadOnlyTest()
        {
            string expectedName = "The name";

            var target = new CategoricalVariable(expectedName);

            target.SetAsReadOnly();

            CategoricalVariableAssert.IsStateAsExpected(
                target,
                expectedName,
                expectedCategories: new List <Category>(),
                expectedReadOnlyFlag: true);
        }
예제 #3
0
        public void ConstructorTest()
        {
            // name is null
            {
                ArgumentExceptionAssert.Throw(
                    () => { new CategoricalVariable(null); },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "name");
            }

            // name is white space
            {
                ArgumentExceptionAssert.Throw(
                    () => { new CategoricalVariable(" "); },
                    expectedType: typeof(ArgumentOutOfRangeException),
                    expectedPartialMessage:
                    ImplementationServices.GetResourceString(
                        "STR_EXCEPT_PAR_STRING_IS_EMPTY_OR_WHITESPACE"),
                    expectedParameterName: "name");
            }

            // name is empty
            {
                ArgumentExceptionAssert.Throw(
                    () => { new CategoricalVariable(string.Empty); },
                    expectedType: typeof(ArgumentOutOfRangeException),
                    expectedPartialMessage:
                    ImplementationServices.GetResourceString(
                        "STR_EXCEPT_PAR_STRING_IS_EMPTY_OR_WHITESPACE"),
                    expectedParameterName: "name");
            }

            // Valid name
            {
                string expectedName = "The name";

                var target = new CategoricalVariable(expectedName);

                CategoricalVariableAssert.IsStateAsExpected(
                    target,
                    expectedName,
                    expectedCategories: new List <Category>(),
                    expectedReadOnlyFlag: false);
            }
        }
예제 #4
0
        public void FromDoubleMatrixByMethodTest()
        {
            // With named rows
            {
                string name = "The name";

                var target = DoubleMatrix.Dense(3, 1,
                                                new double[3] {
                    0.0, 1.0, 2.0
                });
                target.Name = name;
                target.SetRowName(0, "Zero");
                target.SetRowName(1, "One");
                target.SetRowName(2, "Two");

                var actual = CategoricalVariable.FromDoubleMatrix(target);

                var expected = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 1.0, "One" },
                    { 2.0, "Two" }
                };

                CategoricalVariableAssert.AreEqual(expected, actual);
            }

            // With unnamed rows
            {
                string name = "The name";

                var target = DoubleMatrix.Dense(3, 1,
                                                new double[3] {
                    0.0, 1.0, 2.0
                });
                target.Name = name;

                var actual = CategoricalVariable.FromDoubleMatrix(target);

                var expected = new CategoricalVariable(name)
                {
                    0.0,
                    1.0,
                    2.0
                };

                CategoricalVariableAssert.AreEqual(expected, actual);
            }

            // value is null
            {
                DoubleMatrix target = null;

                ArgumentExceptionAssert.Throw(
                    () => { var result = CategoricalVariable.FromDoubleMatrix(target); },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "value");
            }

            // value is not a column vector
            {
                var target = DoubleMatrix.Dense(2, 3);

                ArgumentExceptionAssert.Throw(
                    () => { var result = CategoricalVariable.FromDoubleMatrix(target); },
                    expectedType: typeof(ArgumentOutOfRangeException),
                    expectedPartialMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_PAR_MUST_BE_COLUMN_VECTOR"),
                    expectedParameterName: "value");
            }
        }
예제 #5
0
        public void RemoveByLabelTest()
        {
            // Removing existing category
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 1.0, "One" },
                    { 2.0, "Two" }
                };

                CategoricalVariable actualVariable, expectedVariable;
                bool   actualFlag, expectedFlag;
                string categoryLabel;

                categoryLabel = "One";

                actualFlag     = target.Remove(categoryLabel);
                actualVariable = target;

                expectedFlag = true;

                expectedVariable = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 2.0, "Two" }
                };

                Assert.AreEqual(expectedFlag, actualFlag);
                CategoricalVariableAssert.AreEqual(expectedVariable, actualVariable);
            }

            // Removing not existing category
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 1.0, "One" },
                    { 2.0, "Two" }
                };

                CategoricalVariable actualVariable, expectedVariable;
                bool   actualFlag, expectedFlag;
                string categoryLabel;

                categoryLabel = "Three";

                actualFlag     = target.Remove(categoryLabel);
                actualVariable = target;

                expectedFlag = false;

                expectedVariable = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 1.0, "One" },
                    { 2.0, "Two" }
                };

                Assert.AreEqual(expectedFlag, actualFlag);
                CategoricalVariableAssert.AreEqual(expectedVariable, actualVariable);
            }

            // label is null
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 1.0, "One" },
                    { 2.0, "Two" }
                };

                ArgumentExceptionAssert.Throw(
                    () => { target.Remove(null); },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "label");
            }

            // Removing categories in read-only variables
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 1.0, "One" },
                    { 2.0, "Two" }
                };

                target.SetAsReadOnly();

                ExceptionAssert.Throw(
                    () => { target.Remove("One"); },
                    expectedType: typeof(InvalidOperationException),
                    expectedMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_CAT_VARIABLE_IS_READONLY"));

                ExceptionAssert.Throw(
                    () => { target.Remove("Three"); },
                    expectedType: typeof(InvalidOperationException),
                    expectedMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_CAT_VARIABLE_IS_READONLY"));
            }
        }
예제 #6
0
        public void RemoveByCodeTest()
        {
            // Removing existing category
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 1.0, "One" },
                    { 2.0, "Two" }
                };

                CategoricalVariable actualVariable, expectedVariable;
                bool   actualFlag, expectedFlag;
                double categoryCode;

                categoryCode = 1.0;

                actualFlag     = target.Remove(categoryCode);
                actualVariable = target;

                expectedFlag = true;

                expectedVariable = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 2.0, "Two" }
                };

                Assert.AreEqual(expectedFlag, actualFlag);
                CategoricalVariableAssert.AreEqual(expectedVariable, actualVariable);
            }

            // Removing not existing category
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 1.0, "One" },
                    { 2.0, "Two" }
                };

                CategoricalVariable actualVariable, expectedVariable;
                bool   actualFlag, expectedFlag;
                double categoryCode;

                categoryCode = 3.0;

                actualFlag     = target.Remove(categoryCode);
                actualVariable = target;

                expectedFlag = false;

                expectedVariable = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 1.0, "One" },
                    { 2.0, "Two" }
                };

                Assert.AreEqual(expectedFlag, actualFlag);
                CategoricalVariableAssert.AreEqual(expectedVariable, actualVariable);
            }

            // Removing categories in read-only variables
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name)
                {
                    { 0.0, "Zero" },
                    { 1.0, "One" },
                    { 2.0, "Two" }
                };

                target.SetAsReadOnly();

                ExceptionAssert.Throw(
                    () => { target.Remove(3.0); },
                    expectedType: typeof(InvalidOperationException),
                    expectedMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_CAT_VARIABLE_IS_READONLY"));

                ExceptionAssert.Throw(
                    () => { target.Remove(1.0); },
                    expectedType: typeof(InvalidOperationException),
                    expectedMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_CAT_VARIABLE_IS_READONLY"));
            }
        }
예제 #7
0
        public void AddTest()
        {
            // code already exists
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name)
                {
                    2.0
                };

                ExceptionAssert.Throw(
                    () => { target.Add(2.0, "second two"); },
                    expectedType: typeof(InvalidOperationException),
                    expectedMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_CAT_ALREADY_EXISTS_IN_VARIABLE_LIST"));
            }

            // label already exists
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name)
                {
                    { 2.0, "two" }
                };

                ExceptionAssert.Throw(
                    () => { target.Add(2.000001, "two"); },
                    expectedType: typeof(InvalidOperationException),
                    expectedMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_CAT_ALREADY_EXISTS_IN_VARIABLE_LIST"));
            }

            // label is null
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name);

                ArgumentExceptionAssert.Throw(
                    () => { target.Add(3.0, null); },
                    expectedType: typeof(ArgumentNullException),
                    expectedPartialMessage: ArgumentExceptionAssert.NullPartialMessage,
                    expectedParameterName: "label");
            }

            // label is white space
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name);

                ArgumentExceptionAssert.Throw(
                    () => { target.Add(3.0, " "); },
                    expectedType: typeof(ArgumentOutOfRangeException),
                    expectedPartialMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_PAR_STRING_IS_EMPTY_OR_WHITESPACE"),
                    expectedParameterName: "label");
            }

            // label is empty
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name);

                ArgumentExceptionAssert.Throw(
                    () => { target.Add(3.0, string.Empty); },
                    expectedType: typeof(ArgumentOutOfRangeException),
                    expectedPartialMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_PAR_STRING_IS_EMPTY_OR_WHITESPACE"),
                    expectedParameterName: "label");
            }

            // target is read only
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name);

                target.SetAsReadOnly();

                ExceptionAssert.Throw(
                    () => { target.Add(3.0, "three"); },
                    expectedType: typeof(InvalidOperationException),
                    expectedMessage: ImplementationServices.GetResourceString(
                        "STR_EXCEPT_CAT_VARIABLE_IS_READONLY"));
            }

            // Valid input
            {
                string name   = "The name";
                var    target = new CategoricalVariable(name);

                double   code;
                string   label;
                Category category0, category1;

                code  = 1.0;
                label = "one";
                target.Add(code, label);
                category0 = new Category(code, label);

                code  = 2.0;
                label = "two";
                target.Add(code, label);
                category1 = new Category(code, label);

                CategoricalVariableAssert.IsStateAsExpected(
                    target,
                    name,
                    expectedCategories: new List <Category>(2)
                {
                    category0,
                    category1
                },
                    expectedReadOnlyFlag: false);
            }
        }