Пример #1
0
        public void IsUnknownReturnsFalseForKnownTest()
        {
            var pair = new CirclePair(m_Smaller,
                                      m_Bigger);

            Assert.False(pair.IsUnknown);
        }
Пример #2
0
        public void ZeroTest()
        {
            var pair = new CirclePair(m_Smaller,
                                      m_Bigger);

            Assert.AreEqual(m_Smaller,
                            pair.One);
        }
Пример #3
0
        public void RadiusZeroForFirstIsGreaterTest()
        {
            var pair = new CirclePair(m_Bigger,
                                      m_Smaller);

            Assert.AreEqual(m_Bigger.Radius,
                            pair.RadiusZero);
        }
Пример #4
0
        public void ZeroForSecondIsGreaterTest()
        {
            var pair = new CirclePair(m_Smaller,
                                      m_Bigger);

            Assert.AreEqual(m_Bigger,
                            pair.Zero);
        }
Пример #5
0
        public void DistanceTest()
        {
            var pair = new CirclePair(m_Smaller,
                                      m_Bigger);

            NUnitHelper.AssertIsEquivalent(45.0,
                                           pair.Distance,
                                           0.01,
                                           "Distance");
        }
Пример #6
0
        public void NumberOfTangentsForIntersectingTest()
        {
            var pair = new CirclePair(m_Bigger,
                                      m_ThreeIntersectingTwo);

            const int expected = 2;
            int       actual   = pair.NumberOfTangents;

            Assert.AreEqual(expected,
                            actual);
        }
Пример #7
0
        public void NumberOfTangentsForIntersectingInOnePointTest()
        {
            var pair = new CirclePair(m_Bigger,
                                      m_ThreeInsideTwoIntersectingOnePoint);

            const int expected = 3;
            int       actual   = pair.NumberOfTangents;

            Assert.AreEqual(expected,
                            actual);
        }
Пример #8
0
        public void NumberOfTangentsForCircleInsideOtherTouchingTest()
        {
            var pair = new CirclePair(m_Bigger,
                                      m_ThreeInsideTwoIntersectingTwoPoints);

            const int expected = 1;
            int       actual   = pair.NumberOfTangents;

            Assert.AreEqual(expected,
                            actual);
        }
Пример #9
0
        public void NumberOfTangentsForCircleNotIntersectingTest()
        {
            var pair = new CirclePair(m_Smaller,
                                      m_Bigger);

            const int expected = 4;
            int       actual   = pair.NumberOfTangents;

            Assert.AreEqual(expected,
                            actual);
        }
            public void Setup()
            {
                m_Two = new Circle(1.0,
                                   20.0,
                                   3.0);
                m_One = new Circle(10.0,
                                   20.0,
                                   1.0);
                m_CirclePair = new CirclePair(m_One,
                                              m_Two);

                m_Calculator = new CirclesIntersectionPointsCalculator(m_CirclePair);
            }
Пример #11
0
            public void Setup()
            {
                m_One = new Circle(new Point(3.0,
                                             -5.0),
                                   4.0);
                m_Two = new Circle(new Point(-2.0,
                                             2.0),
                                   1.0);
                m_Pair = new CirclePair(m_One,
                                        m_Two);

                m_Calculator = new InnerTangentLinesIntersectionPointCalculator(m_Pair);
            }
            public void Setup()
            {
                m_CircleOne = new Circle(1.0,
                                         -2.0,
                                         3.0);
                m_CircleZero = new Circle(3.0,
                                          -2.0,
                                          4.0);
                m_CirclePair = new CirclePair(m_CircleZero,
                                              m_CircleOne);

                m_Calculator = new CirclesIntersectionPointsCalculator(m_CirclePair);
            }
            public void Setup()
            {
                m_One = new Circle(new Point(10.0,
                                             14.0),
                                   2.5);
                m_Two = new Circle(new Point(11.0,
                                             2.5),
                                   2.5);
                m_Pair = new CirclePair(m_One,
                                        m_Two);

                m_Calculator = new OuterTangentsCalculator(m_Pair);
            }
Пример #14
0
            public void Setup()
            {
                m_One = new Circle(new Point(2.0,
                                             4.0),
                                   4.0);
                m_Two = new Circle(new Point(10.0,
                                             4.0),
                                   4.0);
                m_Pair = new CirclePair(m_One,
                                        m_Two);

                m_Calculator = new InnerTangentsCalculator(m_Pair);
            }
            public void Setup()
            {
                m_One = new Circle(new Point(2.0,
                                             2.0),
                                   2.0);
                m_Two = new Circle(new Point(7.0,
                                             6.0),
                                   2.0);
                m_Pair = new CirclePair(m_One,
                                        m_Two);

                m_Calculator = new OuterTangentsCalculator(m_Pair);
            }
Пример #16
0
            public void Setup()
            {
                m_One = new Circle(new Point(10.0,
                                             10.0),
                                   5.0);
                m_Two = new Circle(new Point(-20.0,
                                             -20.0),
                                   10.0);
                m_Pair = new CirclePair(m_One,
                                        m_Two);

                m_Calculator = new OuterTangentLinesIntersectionPointCalculator(m_Pair);
            }
            public void ZeroXBiggerThanOneXTest()
            {
                var circle = new Circle(new Point(10.0,
                                                  20.0),
                                        1.0);
                var pair = new CirclePair(m_One,
                                          circle);

                var expected = new Tuple <Point, Point>(new Point(9.0,
                                                                  20.0),
                                                        new Point(11.0,
                                                                  20));
                Tuple <Point, Point> actual = m_Calculator.CalculatePointsForSameY(pair);

                Assert.AreEqual(expected,
                                actual);
            }
            public void DeltaXMinusDoubleRadiusLessInsideEpsilonTest()
            {
                var one = new Circle(1.0,
                                     -2.0,
                                     3.0);
                var two = new Circle(7.0,
                                     -2.0,
                                     3.0);
                var pair = new CirclePair(one,
                                          two);

                var expected = new Tuple <Point, Point>(new Point(4.0,
                                                                  -2.0),
                                                        new Point(4.0,
                                                                  -2.0));
                Tuple <Point, Point> actual = m_Calculator.CalculatePointsForSpecialCases(pair);

                Assert.AreEqual(expected,
                                actual,
                                "IntersectionPointOne");
            }
            public void CalculateTangenPointsForZeroBothSameRadiusTest()
            {
                var one = new Circle(new Point(2.0,
                                               2.0),
                                     2.0);
                var two = new Circle(new Point(7.0,
                                               6.0),
                                     2.0);
                var pair = new CirclePair(one,
                                          two);

                Tuple <Point, Point> actual = m_Calculator.CalculateTangenPointsForZeroBothSameRadius(pair);

                Assert.AreEqual(new Point(5.75,
                                          7.56),
                                actual.Item1,
                                "Item1");
                Assert.AreEqual(new Point(8.25,
                                          4.44),
                                actual.Item2,
                                "Item2");
            }