Esempio n. 1
0
        public void ChainableComparerPassesThroughInputCorrectyWhenSetToOff()
        {
            //Given
            var chainableComparer = new ChainableComparer();

            chainableComparer.IsOn.State = false;

            var truthTable = new List <CompareInputOutput>
            {
                new CompareInputOutput(false, false, isLessThan: true),
                new CompareInputOutput(false, true),
                new CompareInputOutput(true, false, isLessThan: true),
                new CompareInputOutput(true, true, isGreaterThan: true)
            };

            foreach (var t in truthTable)
            {
                //When
                chainableComparer.InputA.State             = t.InputA;
                chainableComparer.InputB.State             = t.InputB;
                chainableComparer.IsLessThanInput.State    = t.IsLessThan;
                chainableComparer.IsGreaterThanInput.State = t.IsGreaterThan;

                //Then
                chainableComparer.IsLessThanOutput.State.Should().Be(t.IsLessThan);
                chainableComparer.IsEqualToOutput.State.Should().Be(t.IsEqualTo);
                chainableComparer.IsGreaterThanOutput.State.Should().Be(t.IsGreaterThan);
            }
        }
        public void Explore()
        {
            Property2ChainableComparer inheritor = new Property2ChainableComparer();

            Assert.That(inheritor, Is.InstanceOf <IComparer <ComparisonSubject> >(), "is a proper comparer");

            ComparisonSubject x = new ComparisonSubject("x", 1, 1m), y = new ComparisonSubject("y", 1, 2m);

            Assert.That(inheritor.Compare(x, y), Is.EqualTo(0), "x.Property2 == y.Property2");

            ChainableComparer <ComparisonSubject> asc  = inheritor.Then(new Property3ChainableComparer());

            Assert.That(x, Is.LessThan(y).Using(asc), "x.Properyty3 < y.Property2");

            ChainableComparer <ComparisonSubject> desc = new Property2ChainableComparer()
                                                         .Then(new Property3ChainableComparer(Direction.Descending));

            Assert.That(x, Is.GreaterThan(y).Using(desc), "x.Properyty3 > y.Property2");

            var chainable = new Property2ChainableComparer();

            Assert.That(chainable.Compare(x, null), Is.GreaterThan(0));
            Assert.That(chainable.Compare(null, y), Is.LessThan(0));
            Assert.That(chainable.Compare(null, null), Is.EqualTo(0));
        }
Esempio n. 3
0
        public void ChainableComparerComparesCorrectlyWhenSetToOn()
        {
            //Given
            var truthTable = new List <CompareInputOutput>
            {
                new CompareInputOutput(false, false, isEqualTo: true),
                new CompareInputOutput(false, true, isLessThan: true),
                new CompareInputOutput(true, false, isGreaterThan: true),
                new CompareInputOutput(true, true, isEqualTo: true),
            };
            var chainableComparer = new ChainableComparer();

            chainableComparer.IsOn.State = true;

            foreach (var t in truthTable)
            {
                Trace.WriteLine(t);

                //When
                chainableComparer.InputA.State = t.InputA;
                chainableComparer.InputB.State = t.InputB;

                //Then
                chainableComparer.IsLessThanOutput.State.Should().Be(t.IsLessThan);
                chainableComparer.IsEqualToOutput.State.Should().Be(t.IsEqualTo);
                chainableComparer.IsGreaterThanOutput.State.Should().Be(t.IsGreaterThan);
            }
        }