public void ValueHolderToStringsNicely()
        {
            ConstructorArgumentValues values = new ConstructorArgumentValues();

            values.AddGenericArgumentValue(1, typeof(int).FullName);
            ConstructorArgumentValues.ValueHolder vh = values.GetGenericArgumentValue(typeof(int));
            Assert.AreEqual("'1' [System.Int32]", vh.ToString());
        }
        /// <summary>
        /// Configures the constructor argument ValueHolder.
        /// </summary>
        /// <param name="valueHolder">The vconstructor alue holder.</param>
        protected void ConfigureConstructorArgument(ConstructorArgumentValues.ValueHolder valueHolder)
        {
            object newVal = ResolveValue(valueHolder.Value);

            if (!ObjectUtils.NullSafeEquals(newVal, valueHolder.Value))
            {
                valueHolder.Value = newVal;
            }
        }
        public void AddNamedArgument()
        {
            ConstructorArgumentValues values = new ConstructorArgumentValues();

            values.AddNamedArgumentValue("foo", "sball");
            Assert.AreEqual(1, values.NamedArgumentValues.Count, "Added one named argument but it doesn't seem to have been added to the named arguments collection.");
            Assert.AreEqual(1, values.ArgumentCount, "Added one named argument but it doesn't seem to be reflected in the overall argument count.");
            ConstructorArgumentValues.ValueHolder arg = values.GetNamedArgumentValue("foo");
            Assert.IsNotNull(arg, "The named argument previously added could not be pulled from the ctor arg collection.");
            Assert.AreEqual("sball", arg.Value, "The value of the named argument passed in is not the same as the one that was pulled out.");
        }
        public void GetGeneric_Untyped_ArgumentValueWithOnlyStronglyTypedValuesInTheCtorValueList()
        {
            ConstructorArgumentValues values = new ConstructorArgumentValues();
            const string expectedValue       = "Rick";

            values.AddGenericArgumentValue(expectedValue, typeof(string).FullName);

            ConstructorArgumentValues.ValueHolder name = values.GetGenericArgumentValue(null, null);
            Assert.IsNull(name,
                          "Must get null valueholder back if no required type is specified but only " +
                          "strongly typed values are present in the ctor values list.");
        }
        public void GetGeneric_Untyped_ArgumentValue()
        {
            ConstructorArgumentValues values = new ConstructorArgumentValues();
            const string expectedValue       = "Rick";

            values.AddGenericArgumentValue(expectedValue);

            ConstructorArgumentValues.ValueHolder name = values.GetGenericArgumentValue(null, null);
            Assert.IsNotNull(name,
                             "Must get non-null valueholder back if no required type is specified.");
            Assert.AreEqual(expectedValue, name.Value);
        }
        public void NamedArgumentsAreCaseInsensitive()
        {
            ConstructorArgumentValues values = new ConstructorArgumentValues();

            values.AddNamedArgumentValue("foo", "sball");
            Assert.AreEqual(1, values.NamedArgumentValues.Count, "Added one named argument but it doesn't seem to have been added to the named arguments collection.");
            Assert.AreEqual(1, values.ArgumentCount, "Added one named argument but it doesn't seem to be reflected in the overall argument count.");
            Assert.IsTrue(values.ContainsNamedArgument("FOo"), "Mmm, the ContainsNamedArgument() method eveidently IS case sensitive (which is wrong).");
            ConstructorArgumentValues.ValueHolder arg = values.GetNamedArgumentValue("fOo");
            Assert.IsNotNull(arg, "The named argument previously added could not be pulled from the ctor arg collection.");
            Assert.AreEqual("sball", arg.Value, "The value of the named argument passed in is not the same as the one that was pulled out.");
        }
        public void GetGenericArgumentValue()
        {
            ConstructorArgumentValues values = new ConstructorArgumentValues();

            Assert.IsNull(values.GetGenericArgumentValue(typeof(object)), "Mmm... managed to get a non null instance back from an empty instance.");
            values.AddGenericArgumentValue(DBNull.Value, typeof(DBNull).FullName);
            Assert.IsNull(values.GetGenericArgumentValue(typeof(string)), "Mmm... managed to get a non null instance back from an instance that should have now't with the specified Type.");
            ConstructorArgumentValues.ValueHolder value =
                values.GetGenericArgumentValue(typeof(DBNull));
            Assert.IsNotNull(value, "Stored a value of a specified Type, but got null when retrieving it using said Type.");
            Assert.AreSame(DBNull.Value, value.Value, "The value stored at the specified index was not the exact same instance as was added.");
        }
        public void GetIndexedArgumentValue()
        {
            ConstructorArgumentValues values = new ConstructorArgumentValues();

            Assert.IsNull(values.GetIndexedArgumentValue(0, typeof(object)), "Mmm... managed to get a non null instance back from an empty instance.");
            values.AddIndexedArgumentValue(16, DBNull.Value, typeof(DBNull).FullName);
            Assert.IsNull(values.GetIndexedArgumentValue(0, typeof(object)), "Mmm... managed to get a non null instance back from an instance that should have now't at the specified index.");
            ConstructorArgumentValues.ValueHolder value =
                values.GetIndexedArgumentValue(16, typeof(DBNull));
            Assert.IsNotNull(value, "Stored a value at a specified index, but got null when retrieving it.");
            Assert.AreSame(DBNull.Value, value.Value, "The value stored at the specified index was not the exact same instance as was added.");
            ConstructorArgumentValues.ValueHolder wrongValue =
                values.GetIndexedArgumentValue(16, typeof(string));
            Assert.IsNull(wrongValue, "Stored a value at a specified index, and got it (or rather something) back when retrieving it with the wrong Type specified.");
        }
        public void GetArgumentValue()
        {
            ConstructorArgumentValues values = new ConstructorArgumentValues();

            Assert.IsNull(values.GetArgumentValue(0, typeof(object)), "Mmm... managed to get a non null instance back from an empty instance.");
            values.AddGenericArgumentValue(DBNull.Value, typeof(DBNull).FullName);
            values.AddNamedArgumentValue("foo", DBNull.Value);
            values.AddIndexedArgumentValue(16, DBNull.Value, typeof(DBNull).FullName);
            Assert.IsNull(values.GetArgumentValue(100, typeof(string)), "Mmm... managed to get a non null instance back from an instance that should have now't with the specified Type.");
            ConstructorArgumentValues.ValueHolder value =
                values.GetArgumentValue(-3, typeof(DBNull));
            Assert.IsNotNull(value, "Stored a value of a specified Type at a specified index, but got null when retrieving it using the wrong index but the correct Type.");
            Assert.AreSame(DBNull.Value, value.Value, "The retrieved value was not the exact same instance as was added.");

            value = values.GetArgumentValue("foo", typeof(DBNull));
            Assert.IsNotNull(value, "Stored a value of a specified Type under a name, but got null when retrieving it using the wrong name but the correct Type.");
            Assert.AreSame(DBNull.Value, value.Value, "The retrieved value was not the exact same instance as was added.");
        }
        public void GetGenericArgumentValueIgnoresAlreadyUsedValues()
        {
            ISet used = new ListSet();

            ConstructorArgumentValues values = new ConstructorArgumentValues();

            values.AddGenericArgumentValue(1);
            values.AddGenericArgumentValue(2);
            values.AddGenericArgumentValue(3);

            Type intType = typeof(int);

            ConstructorArgumentValues.ValueHolder one = values.GetGenericArgumentValue(intType, used);
            Assert.AreEqual(1, one.Value);
            used.Add(one);
            ConstructorArgumentValues.ValueHolder two = values.GetGenericArgumentValue(intType, used);
            Assert.AreEqual(2, two.Value);
            used.Add(two);
            ConstructorArgumentValues.ValueHolder three = values.GetGenericArgumentValue(intType, used);
            Assert.AreEqual(3, three.Value);
            used.Add(three);
            ConstructorArgumentValues.ValueHolder four = values.GetGenericArgumentValue(intType, used);
            Assert.IsNull(four);
        }