예제 #1
0
        public void Test_Equals_negative()
        {
            // two different numbers should not be equal
            var quadOne = new QuartetAurora("12.3b5");
            var quadTwo = new QuartetAurora("17.1a7");

            Assert.IsFalse(quadOne.Equals(quadTwo));
            Assert.IsFalse(quadTwo.Equals(quadOne));

            quadOne = new QuartetAurora("12.3b4");
            quadTwo = new QuartetAurora("15.3b4");
            Assert.IsFalse(quadOne.Equals(quadTwo));
            Assert.IsFalse(quadTwo.Equals(quadOne));

            quadOne = new QuartetAurora("12.3b4");
            quadTwo = new QuartetAurora("12.4b4");
            Assert.IsFalse(quadOne.Equals(quadTwo));
            Assert.IsFalse(quadTwo.Equals(quadOne));

            quadOne = new QuartetAurora("12.3a4");
            quadTwo = new QuartetAurora("12.3b4");
            Assert.IsFalse(quadOne.Equals(quadTwo));
            Assert.IsFalse(quadTwo.Equals(quadOne));

            quadOne = new QuartetAurora("12.3b5");
            quadTwo = new QuartetAurora("12.3b6");
            Assert.IsFalse(quadOne.Equals(quadTwo));
            Assert.IsFalse(quadTwo.Equals(quadOne));
        }
예제 #2
0
        public void Test_CompareTo_Greater()
        {
            var quadOne = new QuartetAurora("9.6b1");
            var quadTwo = new QuartetAurora("12.3b4");

            Assert.IsTrue(quadOne.CompareTo(quadTwo) < 0);
            Assert.IsTrue(quadTwo.CompareTo(quadOne) > 0);
        }
예제 #3
0
        public void Test_constructor_malformedString()
        {
            // constructor with parameter should set only numeric parts
            var four = new QuartetAurora("12.3foo7");

            Assert.AreEqual <uint>(12, four.major);
            Assert.AreEqual <uint>(0, four.minor);
            Assert.AreEqual <char>('b', four.patch);
            Assert.AreEqual <uint>(0, four.build);
        }
예제 #4
0
        public void Test_operatorGreater()
        {
            var quadOne   = new QuartetAurora("9.6b1");
            var quadTwo   = new QuartetAurora("12.3b4");
            var quadThree = new QuartetAurora("12.3b4");

            Assert.IsFalse(quadOne > quadTwo);
            Assert.IsTrue(quadTwo > quadOne);
            Assert.IsFalse(quadTwo > quadThree);
            Assert.IsFalse(quadThree > quadTwo);
        }
예제 #5
0
        public void Test_operatorLess()
        {
            var quadOne   = new QuartetAurora("9.6b1");
            var quadTwo   = new QuartetAurora("12.3b4");
            var quadThree = new QuartetAurora("12.3b4");

            Assert.IsTrue(quadOne < quadTwo);
            Assert.IsFalse(quadTwo < quadOne);
            Assert.IsFalse(quadTwo < quadThree);
            Assert.IsFalse(quadThree < quadTwo);
        }
예제 #6
0
        public void Test_CompareTo_Equal()
        {
            var quadOne = new QuartetAurora("12.3b4");
            var quadTwo = new QuartetAurora("12.3b4");

            Assert.AreEqual(0, quadOne.CompareTo(quadTwo));
            Assert.AreEqual(0, quadTwo.CompareTo(quadOne));
            // self comparison
            Assert.AreEqual(0, quadOne.CompareTo(quadOne));
            Assert.AreEqual(0, quadTwo.CompareTo(quadTwo));
        }
예제 #7
0
        public void Test_Equals()
        {
            var quadOne = new QuartetAurora("12.3b56");
            var quadTwo = new QuartetAurora("12.3b56");

            // two instances should be equal
            Assert.IsTrue(quadOne.Equals(quadTwo));
            Assert.IsTrue(quadTwo.Equals(quadOne));
            // self equality
            Assert.IsTrue(quadOne.Equals(quadOne));
            Assert.IsTrue(quadTwo.Equals(quadTwo));
        }
예제 #8
0
        public void Test_constructor()
        {
            // default constructor should set 0.0b0
            var qa = new QuartetAurora();

            Assert.AreEqual <uint>(0, qa.major);
            Assert.AreEqual <uint>(0, qa.minor);
            Assert.AreEqual <char>('b', qa.patch);
            Assert.AreEqual <uint>(0, qa.build);

            // constructor with parameter should set version numbers
            qa = new QuartetAurora("54.2a5");
            Assert.AreEqual <uint>(54, qa.major);
            Assert.AreEqual <uint>(2, qa.minor);
            Assert.AreEqual <char>('a', qa.patch);
            Assert.AreEqual <uint>(5, qa.build);
        }
예제 #9
0
        public void Test_constructor_short()
        {
            //constructor with parameter should set missing parts to zero
            var four = new QuartetAurora("12.1b");

            Assert.AreEqual <uint>(12, four.major);
            Assert.AreEqual <uint>(0, four.minor);
            Assert.AreEqual <char>('b', four.patch);
            Assert.AreEqual <uint>(0, four.build);

            four = new QuartetAurora("12.1");
            Assert.AreEqual <uint>(12, four.major);
            Assert.AreEqual <uint>(0, four.minor);
            Assert.AreEqual <char>('b', four.patch);
            Assert.AreEqual <uint>(0, four.build);

            four = new QuartetAurora("12");
            Assert.AreEqual <uint>(12, four.major);
            Assert.AreEqual <uint>(0, four.minor);
            Assert.AreEqual <char>('b', four.patch);
            Assert.AreEqual <uint>(0, four.build);
        }