public void ToInteger_OnDecimal_ReturnsInteger()
            {
                var fixture = new RandomNumberFixture();
                var decimalValue = fixture.Create<decimal>();
                int intValue = Convert.ToInt32(decimalValue);

                Assert.That(() => decimalValue.To<int>(), Is.EqualTo(intValue));
            }

            public void Left_OnNullString_ThrowsValidationException()
            {
                string nullString = null;
                var fixture = new RandomNumberFixture();
                var intValue = fixture.Create<int>();

                Assert.That(() => nullString.Left(intValue), Throws.TypeOf<ValidationException>().With.InnerException.TypeOf<ArgumentNullException>());
            }

            public void ToOrNull_ToBadConvertible_OnAnyInteger_OutNull()
            {
                var fixture = new RandomNumberFixture();
                IConvertible outParameter;
                fixture.Create<int>().ToOrNull(out outParameter);

                Assert.That(() => outParameter, Is.Null);
            }

            public void ToOrNull_ToBadConvertible_OnAnyInteger_ReturnsFalse()
            {
                var fixture = new RandomNumberFixture();
                IConvertible outParameter;
                var actual = fixture.Create<int>().ToOrNull(out outParameter);

                Assert.That(() => actual, Is.False);
            }

            public void Left_OnEmptyString_ReturnsEmptyString()
            {
                var emptyString = string.Empty;
                var fixture = new RandomNumberFixture();
                var intValue = fixture.Create<int>();

                Assert.That(() => emptyString.Left(intValue), Is.Empty);
            }

            public void ToFloat_OnDecimal_ReturnsFloat()
            {
                var fixture = new RandomNumberFixture();
                var decimalValue = fixture.Create<decimal>();
                float floatValue = Convert.ToSingle(decimalValue);

                Assert.That(() => decimalValue.To<float>(), Is.EqualTo(floatValue));
            }

            public void Left_OnNullString_WithNegativeLength_ThrowsValidationException()
            {
                string nullString = null;
                var fixture = new RandomNumberFixture();
                var intValue = fixture.Create<int>();
                intValue = -intValue;

                Assert.That(() => nullString.Left(intValue), Throws.TypeOf<ValidationException>().With.InnerException.TypeOf<MultiException>());
            }

            public void ToOrOther_ToInteger_OnNullStringWithInteger_OutInteger()
            {
                string nullString = null;
                var fixture = new RandomNumberFixture();
                var intValue = fixture.Create<int>();
                int outParameter;
                nullString.ToOrOther(out outParameter, intValue);

                Assert.That(() => outParameter, Is.EqualTo(intValue));
            }

            public void Parse_ToDecimal_OnNegativeInteger_ReturnsDecimal()
            {
                var fixture = new RandomNumberFixture();
                var intValue = Math.Abs(fixture.Create<int>());
                intValue++;
                var negativeInt = -intValue / (intValue + 1);
                var negativeIntString = negativeInt.ToString();
                var converted = Convert.ToDecimal(negativeIntString);

                Assert.That(() => negativeIntString.Parse<decimal>(), Is.EqualTo(converted));
            }

            public void Parse_ToDecimal_OnPositiveDecimal_ReturnsDecimal()
            {
                var fixture = new RandomNumberFixture();
                var decimalValue = Math.Abs(fixture.Create<decimal>());
                decimalValue++;
                var positiveDecimal = decimalValue / (decimalValue + 1);
                var positiveDecimalString = positiveDecimal.ToString("F");
                var converted = Convert.ToDecimal(positiveDecimalString);

                Assert.That(() => positiveDecimalString.Parse<decimal>(), Is.EqualTo(converted));
            }

            public void AverageOrDefault_OnNullIntSequence_WithDoubleFunc_WithDoubleValue_ReturnsDoubleValue()
            {
                IEnumerable<int> nullIntSequence = null;
                var fixture = new RandomNumberFixture();
                var doubleFunc = fixture.Create<Func<int, double>>();
                var doubeValue = fixture.Create<double>();

                Assert.That(() => nullIntSequence.AverageOrDefault(doubleFunc, doubeValue), Is.EqualTo(doubeValue));
            }

            public void AverageOrDefault_OnEmptyDecimalSequence_WithDecimalValue_ReturnsDecimalValue()
            {
                var fixture = new RandomNumberFixture();
                var emtpyDecimalSequence = Enumerable.Empty<decimal>();
                var decimalValue = fixture.Create<decimal>();

                Assert.That(() => emtpyDecimalSequence.AverageOrDefault(decimalValue), Is.EqualTo(decimalValue));
            }

            public void AverageOrDefault_OnNullDecimalSequence_WithDecimalValue_ReturnsDecimalValue()
            {
                IEnumerable<decimal> nullDecimalSequence = null;
                var fixture = new RandomNumberFixture();
                var decimalValue = fixture.Create<decimal>();

                Assert.That(() => nullDecimalSequence.AverageOrDefault(decimalValue), Is.EqualTo(decimalValue));
            }

            public void AverageOrDefault_OnEmptyNullableLongSequence_WithLongValue_ReturnsLongValue()
            {
                var fixture = new RandomNumberFixture();
                var emptyNullableLongSequnce = Enumerable.Empty<long?>();
                var longValue = fixture.Create<long>();

                Assert.That(() => emptyNullableLongSequnce.AverageOrDefault(longValue), Is.EqualTo(longValue));
            }

            public void AverageOrDefault_OnEmptyNullableIntSequence_WithIntValue_ReturnsIntValue()
            {
                var fixture = new RandomNumberFixture();
                var emptyNullableIntSequence = Enumerable.Empty<int?>();
                var intValue = fixture.Create<int>();

                Assert.That(() => emptyNullableIntSequence.AverageOrDefault(intValue), Is.EqualTo(intValue));
            }

            public void MaxOrDefault_OnEmptyIntSequence_WithNullableIntFunc_ReturnsDefaultInt()
            {
                var fixture = new RandomNumberFixture();
                var emptyIntSequence = Enumerable.Empty<int>();
                var nullableIntFunc = fixture.Create<Func<int, int?>>();

                Assert.That(() => emptyIntSequence.MaxOrDefault(nullableIntFunc), Is.EqualTo(default(int)));
            }

            public void ToString_OnTestInteger_ReturnsTestIntegerString()
            {
                var fixture = new RandomNumberFixture();
                var intValue = fixture.Create<int>();
                var intString = intValue.ToString();

                Assert.That(() => intValue.To<string>(), Is.EqualTo(intString));
            }

            public void AverageOrDefault_OnEmptyIntSequence_WithNullableDuoubleFunc_WithDoubleValue_ReturnsDoubleValue()
            {
                var fixture = new RandomNumberFixture();
                var emptyIntSequence = Enumerable.Empty<int>();
                var nullableDoubleFunc = fixture.Create<Func<int, double?>>();
                var doubleValue = fixture.Create<double>();

                Assert.That(() => emptyIntSequence.AverageOrDefault(nullableDoubleFunc, doubleValue), Is.EqualTo(doubleValue));
            }

            public void AverageOrDefault_OnNullIntSequence_WithNullableLongFunc_WithLongValue_ReturnsLongValue()
            {
                IEnumerable<int> nullIntSequence = null;
                var fixture = new RandomNumberFixture();
                var nullableLongFunc = fixture.Create<Func<int, long?>>();
                var longValue = fixture.Create<long>();

                Assert.That(() => nullIntSequence.AverageOrDefault(nullableLongFunc, longValue), Is.EqualTo(longValue));
            }

            public void AverageOrDefault_OnNullIntSequence_WithNullableDecimalFunc_WithDecimalValue_ReturnsDecimalValue()
            {
                IEnumerable<int> nullIntSequence = null;
                var fixture = new RandomNumberFixture();
                var nullableDecimalFunc = fixture.Create<Func<int, decimal?>>();
                var decimalValue = fixture.Create<decimal>();

                Assert.That(() => nullIntSequence.AverageOrDefault(nullableDecimalFunc, decimalValue), Is.EqualTo(decimalValue));
            }