public void VerifyWeaklyTypedCombine()
        {
            var combiner = ThreeObjects.Combine(TwoObjects, FourCharacters.OfType <object>().ToArray());

            VerifyAspect(combiner
                         , x => x.AssertEqual(ThreeObjects)
                         , x => x.AssertEqual(TwoObjects)
                         , x => x.AssertEqual(FourCharacters.OfType <object>())
                         );
        }
        public void VerifyStronglyTypedCombine()
        {
            // ReSharper disable RedundantTypeArgumentsOfMethod
            var combiner = FourCharacters.Combine <char, int>(TwoIntegers);

            VerifyAspect(combiner
                         , x => Assert.Equal(FourCharacters.OfType <object>(), x)
                         , x => Assert.Equal(TwoIntegers.OfType <object>(), x)
                         );
        }
        public void VerifyStronglyTypedCombine()
        {
#pragma warning disable IDE0001 // Name can be simplified
            // ReSharper disable RedundantTypeArgumentsOfMethod
            var combiner = FourCharacters.Combine <char, int>(TwoIntegers);
#pragma warning restore IDE0001 // Name can be simplified

            VerifyAspect(combiner
                         , x => x.AssertEqual(FourCharacters.OfType <object>())
                         , x => x.AssertEqual(TwoIntegers.OfType <object>())
                         );
        }
        public void VerifyWeaklyTypedAppend()
        {
            var combiner = ThreeObjects.Combine(TwoObjects);
            // Make sure that we are using the Object[] params version.
            var appended = combiner.Append(FourCharacters.OfType <object>(), FiveBooleans.OfType <object>());

            appended.AssertNotNull().AssertNotSame(combiner);

            VerifyAspect(appended
                         , x => x.AssertEqual(ThreeObjects)
                         , x => x.AssertEqual(TwoObjects)
                         , x => x.AssertEqual(FourCharacters.OfType <object>())
                         , x => x.AssertEqual(FiveBooleans.OfType <object>())
                         );
        }
        public void VerifyStronglyTypedAppend()
        {
            var combiner = ThreeObjects.Combine(TwoObjects);
            // Make sure that we are using the Strongly Typed Version.
            var appended = combiner.Append <char>(FourCharacters);

            Assert.NotNull(appended);
            Assert.NotSame(combiner, appended);

            VerifyAspect(appended
                         , x => Assert.Equal(ThreeObjects, x)
                         , x => Assert.Equal(TwoObjects, x)
                         , x => Assert.Equal(FourCharacters.OfType <object>(), x)
                         );
        }
        public void VerifyStronglyTypedAppend()
        {
            var combiner = ThreeObjects.Combine(TwoObjects);

            // Make sure that we are using the Strongly Typed Version.
#pragma warning disable IDE0001 // Name can be simplified
            // ReSharper disable RedundantTypeArgumentsOfMethod
            var appended = combiner.Append <char>(FourCharacters);
#pragma warning restore IDE0001 // Name can be simplified

            combiner.AssertNotNull().AssertNotSame(appended);

            VerifyAspect(appended
                         , x => x.AssertEqual(ThreeObjects)
                         , x => x.AssertEqual(TwoObjects)
                         , x => x.AssertEqual(FourCharacters.OfType <object>())
                         );
        }