public void Test_Equality()
        {
            MechanicalPoint p = new MechanicalPoint(), q = new MechanicalPoint();

            p.RAm           = 1.23456789;
            p.DECm          = 1.23456789;
            p.PointingState = MechanicalPoint.PointingStates.POINTING_NORMAL;
            q.RAm           = 1.23456789;
            q.DECm          = 1.23456789;
            q.PointingState = MechanicalPoint.PointingStates.POINTING_NORMAL;
            Assert.IsTrue(p == q);
            Assert.IsFalse(p != q);
            q.PointingState = MechanicalPoint.PointingStates.POINTING_BEYOND_POLE;
            Assert.IsFalse(p == q);
            Assert.IsTrue(p != q);
            q.PointingState = MechanicalPoint.PointingStates.POINTING_NORMAL;
            q.RAm           = q.RAm + 15.0 / 3600.0;
            Assert.IsFalse(p == q);
            Assert.IsTrue(p != q);
            q.RAm = q.RAm - 15.0 / 3600.0;
            Assert.IsTrue(p == q);
            Assert.IsFalse(p != q);
            q.DECm = q.DECm + 1.0 / 3600.0;
            Assert.IsFalse(p == q);
            Assert.IsTrue(p != q);
            q.DECm = q.DECm - 1.0 / 3600.0;
            Assert.IsTrue(p == q);
            Assert.IsFalse(p != q);
        }
        public void Test_RADistance()
        {
            MechanicalPoint p = new MechanicalPoint(), q = new MechanicalPoint();

            Assert.AreEqual(0.0, p.RAsky = 0.0);
            Assert.AreEqual(1.0, q.RAsky = 1.0);
            Assert.AreEqual(1.0 * 15, p.RA_degrees_to(q));
            Assert.AreEqual(-1.0 * 15, q.RA_degrees_to(p));

            Assert.AreEqual(2.0, q.RAsky = 2.0);
            Assert.AreEqual(2.0 * 15, p.RA_degrees_to(q));
            Assert.AreEqual(-2.0 * 15, q.RA_degrees_to(p));

            Assert.AreEqual(8.0, q.RAsky = 8.0);
            Assert.AreEqual(8.0 * 15, p.RA_degrees_to(q));
            Assert.AreEqual(-8.0 * 15, q.RA_degrees_to(p));

            Assert.AreEqual(12.0, q.RAsky = 12.0);
            Assert.AreEqual(12.0 * 15, p.RA_degrees_to(q));
            Assert.AreEqual(-12.0 * 15, q.RA_degrees_to(p));

            Assert.AreEqual(18.0, q.RAsky = 18.0);
            Assert.AreEqual(-6.0 * 15, p.RA_degrees_to(q));
            Assert.AreEqual(+6.0 * 15, q.RA_degrees_to(p));
        }
        public void Test_BeyondPolePointing_RA_Conversions()
        {
            MechanicalPoint p = new MechanicalPoint();
            String          b = "";

            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState = MechanicalPoint.PointingStates.POINTING_BEYOND_POLE);

            Assert.IsFalse(p.parseStringRA("00:00:00"));
            Assert.AreEqual(+12.0, p.RAsky);
            Assert.AreEqual("00:00:00", p.toStringRA(ref b));

            Assert.IsFalse(p.parseStringRA("06:00:00"));
            Assert.AreEqual(+18.0, p.RAsky);
            Assert.AreEqual("06:00:00", p.toStringRA(ref b));

            Assert.IsFalse(p.parseStringRA("12:00:00"));
            Assert.AreEqual(+0.0, p.RAsky);
            Assert.AreEqual("12:00:00", p.toStringRA(ref b));

            Assert.IsFalse(p.parseStringRA("18:00:00"));
            Assert.AreEqual(+6.0, p.RAsky);
            Assert.AreEqual("18:00:00", p.toStringRA(ref b));

            Assert.IsFalse(p.parseStringRA("24:00:00"));
            Assert.AreEqual(+12.0, p.RAsky);
            Assert.AreEqual("00:00:00", p.toStringRA(ref b));
        }
        public void Test_Stability_RA_Conversions()
        {
            MechanicalPoint.PointingStates[] sides = { MechanicalPoint.PointingStates.POINTING_NORMAL, MechanicalPoint.PointingStates.POINTING_BEYOND_POLE };
            for (int ps = 0; ps < sides.Length; ps++)
            {
                for (int s = 0; s < 60; s++)
                {
                    for (int m = 0; m < 60; m++)
                    {
                        for (int h = 0; h < 24; h++)
                        {
                            // Locals are on purpose - reset test material on each loop
                            MechanicalPoint p = new MechanicalPoint();
                            String          b = "", c = "";

                            p.PointingState = sides[ps];

                            b = $"{h:D2}:{m:D2}:{s:D2}";
                            p.parseStringRA(b);
                            p.toStringRA(ref c);

                            // Debug test with this block
                            if (b != c[0] + c.Substring(2))
                            {
                                p.parseStringRA(b);
                                p.toStringRA(ref c);
                            }

                            Assert.AreEqual(b, c);
                        }
                    }
                }
            }
        }
        public bool getCurrentMechanicalPosition(ref MechanicalPoint p)
        {
            Assert.IsTrue(device.Connected);
            String result = device.CommandString("getCurrentMechanicalPosition", false);

            String[] radec = result.Split(new char[] { ' ' });
            Assert.IsFalse(p.parseStringRA(radec[0]));
            Assert.IsFalse(p.parseStringDEC(radec[1]));
            return(false);
        }
        public void Test_Stability_DEC_Conversions()
        {
            // Specific test under one degree for positive and negative values of mechanical position
            {
                MechanicalPoint mp = new MechanicalPoint(0, -0.87);
                Assert.AreEqual(-0.87, mp.DECm);
                String s = "";
                Assert.AreEqual("-000:52:12", mp.toStringDEC(ref s));
                Assert.AreEqual("-00:52:12", mp.toStringDEC_Sim(ref s));
            }
            {
                MechanicalPoint mp = new MechanicalPoint(0, +0.87);
                Assert.AreEqual(+0.87, mp.DECm);
                String s = "";
                Assert.AreEqual("+000:52:12", mp.toStringDEC(ref s));
                Assert.AreEqual("+00:52:12", mp.toStringDEC_Sim(ref s));
            }

            // Doesn't test outside of -90,+90 but another test does roughly
            MechanicalPoint.PointingStates[] sides = { MechanicalPoint.PointingStates.POINTING_NORMAL, MechanicalPoint.PointingStates.POINTING_BEYOND_POLE };
            for (int ps = 0; ps < sides.Length; ps++)
            {
                for (int s = 0; s < 60; s++)
                {
                    for (int m = 0; m < 60; m++)
                    {
                        for (int d = -89; d <= +89; d++)
                        {
                            // Locals are on purpose - reset test material on each loop
                            MechanicalPoint p = new MechanicalPoint();
                            String          b = "", c = "";

                            p.PointingState = sides[ps];

                            b = $"{d:+00;-00;+00}:{m:00}:{s:00}";
                            p.parseStringDEC(b);
                            p.toStringDEC(ref c);

                            // Debug test with this block
                            if (b != c[0] + c.Substring(2))
                            {
                                p.parseStringDEC(b);
                                p.toStringDEC(ref c);
                            }

                            Assert.AreEqual(b, c[0] + c.Substring(2));

                            Assert.IsTrue(0 <= p.RAm && p.RAm <= +24);
                            Assert.IsTrue(-256 <= p.DECm && p.DECm <= 256);
                        }
                    }
                }
            }
        }
        public void Test_PierFlip()
        {
            MechanicalPoint p = new MechanicalPoint();
            String          b = "";

            // Mechanical point doesn't care about LST as it assumes the mount
            // is properly synced already. It only considers the pointing state.

            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState = MechanicalPoint.PointingStates.POINTING_BEYOND_POLE);
            Assert.AreEqual(0.0, p.RAsky    = +0.0);
            Assert.AreEqual(+90.0, p.DECsky = +90.0);
            Assert.AreEqual("12:00:00", p.toStringRA(ref b));
            Assert.AreEqual("+000:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState = MechanicalPoint.PointingStates.POINTING_NORMAL);
            Assert.AreEqual(0.0, p.RAsky    = +0.0);
            Assert.AreEqual(+90.0, p.DECsky = +90.0);
            Assert.AreEqual("00:00:00", p.toStringRA(ref b));
            Assert.AreEqual("+000:00:00", p.toStringDEC(ref b));

            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState = MechanicalPoint.PointingStates.POINTING_BEYOND_POLE);
            Assert.AreEqual(0.0, p.RAsky    = +0.0);
            Assert.AreEqual(+80.0, p.DECsky = +80.0);
            Assert.AreEqual("12:00:00", p.toStringRA(ref b));
            Assert.AreEqual("-010:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState = MechanicalPoint.PointingStates.POINTING_NORMAL);
            Assert.AreEqual(0.0, p.RAsky    = +0.0);
            Assert.AreEqual(+80.0, p.DECsky = +80.0);
            Assert.AreEqual("00:00:00", p.toStringRA(ref b));
            Assert.AreEqual("+010:00:00", p.toStringDEC(ref b));

            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState = MechanicalPoint.PointingStates.POINTING_BEYOND_POLE);
            Assert.AreEqual(0.0, p.RAsky    = +0.0);
            Assert.AreEqual(+70.0, p.DECsky = +70.0);
            Assert.AreEqual("12:00:00", p.toStringRA(ref b));
            Assert.AreEqual("-020:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState = MechanicalPoint.PointingStates.POINTING_NORMAL);
            Assert.AreEqual(0.0, p.RAsky    = +0.0);
            Assert.AreEqual(+70.0, p.DECsky = +70.0);
            Assert.AreEqual("00:00:00", p.toStringRA(ref b));
            Assert.AreEqual("+020:00:00", p.toStringDEC(ref b));
        }
        public void Test_NormalPointing_RA_Conversions()
        {
            MechanicalPoint p = new MechanicalPoint();
            String          b = "";


            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState = MechanicalPoint.PointingStates.POINTING_NORMAL);

            Assert.IsFalse(p.parseStringRA("00:00:00"));
            Assert.AreEqual(+0.0, p.RAsky);

            Assert.AreEqual("00:00:00", p.toStringRA(ref b));

            Assert.IsFalse(p.parseStringRA("06:00:00"));
            Assert.AreEqual(+6.0, p.RAsky);
            Assert.AreEqual("06:00:00", p.toStringRA(ref b));

            Assert.IsFalse(p.parseStringRA("12:00:00"));
            Assert.AreEqual(+12.0, p.RAsky);
            Assert.AreEqual("12:00:00", p.toStringRA(ref b));

            Assert.IsFalse(p.parseStringRA("18:00:00"));
            Assert.AreEqual(+18.0, p.RAsky);
            Assert.AreEqual("18:00:00", p.toStringRA(ref b));

            Assert.IsFalse(p.parseStringRA("24:00:00"));
            Assert.AreEqual(+0.0, p.RAsky);
            Assert.AreEqual("00:00:00", p.toStringRA(ref b));

            Assert.IsFalse(p.parseStringRA("00:00:01"));
            Assert.IsTrue(Math.Abs(p.RAsky - (1 / 3600.0)) <= (1 / 3600.0));
            Assert.AreEqual("00:00:01", p.toStringRA(ref b));

            Assert.IsFalse(p.parseStringRA("00:01:00"));
            Assert.IsTrue(Math.Abs(p.RAsky - (1 / 60.0)) <= (1 / 3600.0));
            Assert.AreEqual("00:01:00", p.toStringRA(ref b));
        }
        public void TestSyncing()
        {
            Assert.IsFalse(device.Connected);
            device.Connected = true;
            Assert.IsTrue(device.CanSync);
            Assert.IsFalse(device.CanSyncAltAz);
            Assert.ThrowsException <ASCOM.MethodNotImplementedException>(() => device.SyncToAltAz(0, 0));

            /*
             * for (int ra = 0; ra < 24 * 60 * 60; ra++)
             * {
             *  for (int dec = -89 * 60 * 60; dec < 89 * 60 * 60; dec++)
             *  {
             *      double RA = ra / 3600.0;
             *      double DEC = dec / 3600.0;
             *      device.SyncToCoordinates(RA, DEC);
             *      Assert.AreEqual(RA, device.RightAscension);
             *      Assert.AreEqual(DEC, device.Declination);
             *  }
             * }
             */

            MechanicalPoint p = new MechanicalPoint();

            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(0.0, p.RAm);
            Assert.AreEqual(0.0, p.DECm);
            Assert.AreEqual(0.0, p.RAsky);
            Assert.AreEqual(90.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            Assert.ThrowsException <ASCOM.InvalidValueException>(() => device.SyncToCoordinates(-0.1, 0));
            Assert.ThrowsException <ASCOM.InvalidValueException>(() => device.SyncToCoordinates(+24.1, 0));
            Assert.ThrowsException <ASCOM.InvalidValueException>(() => device.SyncToCoordinates(0, -91));
            Assert.ThrowsException <ASCOM.InvalidValueException>(() => device.SyncToCoordinates(0, +91));

            device.SyncToCoordinates(0, 0);
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(0.0, p.RAm);
            Assert.AreEqual(90.0, p.DECm);
            Assert.AreEqual(0.0, p.RAsky);
            Assert.AreEqual(0.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.SyncToCoordinates(10, 0);
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(10.0, p.RAm);
            Assert.AreEqual(90.0, p.DECm);
            Assert.AreEqual(10.0, p.RAsky);
            Assert.AreEqual(0.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.SyncToCoordinates(14, 0);
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(14.0, p.RAm);
            Assert.AreEqual(90.0, p.DECm);
            Assert.AreEqual(14.0, p.RAsky);
            Assert.AreEqual(0.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.SyncToCoordinates(0, 10);
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(0.0, p.RAm);
            Assert.AreEqual(80.0, p.DECm);
            Assert.AreEqual(0.0, p.RAsky);
            Assert.AreEqual(10.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.SyncToCoordinates(0, -10);
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(0.0, p.RAm);
            Assert.AreEqual(100.0, p.DECm);
            Assert.AreEqual(0.0, p.RAsky);
            Assert.AreEqual(-10.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.SyncToCoordinates(14, -10);
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(14.0, p.RAm);
            Assert.AreEqual(100.0, p.DECm);
            Assert.AreEqual(14.0, p.RAsky);
            Assert.AreEqual(-10.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.SyncToCoordinates(0, 0);
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(0.0, p.RAm);
            Assert.AreEqual(90.0, p.DECm);
            Assert.AreEqual(0.0, p.RAsky);
            Assert.AreEqual(0.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.TargetRightAscension = 10;
            device.TargetDeclination    = 0;
            device.SyncToTarget();
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(10.0, p.RAm);
            Assert.AreEqual(90.0, p.DECm);
            Assert.AreEqual(10.0, p.RAsky);
            Assert.AreEqual(0.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.TargetRightAscension = 14;
            device.TargetDeclination    = 0;
            device.SyncToTarget();
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(14.0, p.RAm);
            Assert.AreEqual(90.0, p.DECm);
            Assert.AreEqual(14.0, p.RAsky);
            Assert.AreEqual(0.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.TargetRightAscension = 0;
            device.TargetDeclination    = 10;
            device.SyncToTarget();
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(0.0, p.RAm);
            Assert.AreEqual(80.0, p.DECm);
            Assert.AreEqual(0.0, p.RAsky);
            Assert.AreEqual(10.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.TargetRightAscension = 0;
            device.TargetDeclination    = -10;
            device.SyncToTarget();
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(0.0, p.RAm);
            Assert.AreEqual(100.0, p.DECm);
            Assert.AreEqual(0.0, p.RAsky);
            Assert.AreEqual(-10.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            device.TargetRightAscension = 14;
            device.TargetDeclination    = -10;
            device.SyncToTarget();
            Assert.IsFalse(getCurrentMechanicalPosition(ref p));
            Assert.AreEqual(14.0, p.RAm);
            Assert.AreEqual(100.0, p.DECm);
            Assert.AreEqual(14.0, p.RAsky);
            Assert.AreEqual(-10.0, p.DECsky);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
        }
        public void Test_DEC_Conversions()
        {
            MechanicalPoint p = new MechanicalPoint();
            String          b = "";

            Assert.IsFalse(p.parseStringDEC("-I5:00:00"));
            Assert.AreEqual(-255.0, p.DECm);
            Assert.AreEqual("-I5:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("-255:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("-F5:00:00"));
            Assert.AreEqual(-225.0, p.DECm);
            Assert.AreEqual("-F5:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("-225:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("-B0:00:00"));
            Assert.AreEqual(-180.0, p.DECm);
            Assert.AreEqual("-B0:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("-180:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("-=5:00:00"));
            Assert.AreEqual(-135.0, p.DECm);
            Assert.AreEqual("-=5:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("-135:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("-90:00:00"));
            Assert.AreEqual(-90.0, p.DECm);
            Assert.AreEqual("-90:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("-090:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("-45:00:00"));
            Assert.AreEqual(-45.0, p.DECm);
            Assert.AreEqual("-45:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("-045:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("+00:00:00"));
            Assert.AreEqual(+0.0, p.DECm);
            Assert.AreEqual("+00:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("+000:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("+45:00:00"));
            Assert.AreEqual(+45.0, p.DECm);
            Assert.AreEqual("+45:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("+045:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("+90:00:00"));
            Assert.AreEqual(+90.0, p.DECm);
            Assert.AreEqual("+90:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("+090:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("+=5:00:00"));
            Assert.AreEqual(+135.0, p.DECm);
            Assert.AreEqual("+=5:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("+135:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("+B0:00:00"));
            Assert.AreEqual(+180.0, p.DECm);
            Assert.AreEqual("+B0:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("+180:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("+F5:00:00"));
            Assert.AreEqual(+225.0, p.DECm);
            Assert.AreEqual("+F5:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("+225:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("+I5:00:00"));
            Assert.AreEqual(+255.0, p.DECm);
            Assert.AreEqual("+I5:00:00", p.toStringDEC_Sim(ref b));
            Assert.AreEqual("+255:00:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("+00:00:01"));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
            Assert.IsTrue(Math.Abs(p.DECm - (+1 / 3600.0)) <= (1 / 3600.0));
            Assert.AreEqual("+000:00:01", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
            Assert.IsFalse(p.parseStringDEC("+00:01:00"));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
            Assert.IsTrue(Math.Abs(p.DECm - (+1 / 60.0)) <= (1 / 3600.0));
            Assert.AreEqual("+000:01:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);

            Assert.IsFalse(p.parseStringDEC("-00:00:01"));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);
            Assert.IsTrue(Math.Abs(p.DECm - (-1 / 3600.0)) <= (1 / 3600.0));
            Assert.AreEqual("-000:00:01", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);
            Assert.IsFalse(p.parseStringDEC("-00:01:00"));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);
            Assert.IsTrue(Math.Abs(p.DECm - (-1 / 60.0)) <= (1 / 3600.0));
            Assert.AreEqual("-000:01:00", p.toStringDEC(ref b));
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);

            // Negative tests
            Assert.IsTrue(p.parseStringDEC("+J0:00:00"));
            Assert.IsTrue(p.parseStringDEC("-J0:00:00"));
        }
        public void Test_Sky_DEC_Conversion()
        {
            MechanicalPoint p = new MechanicalPoint();

            Assert.AreEqual(-255.0, p.DECm = -255.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
            Assert.AreEqual(-15.0, p.DECsky);
            Assert.AreEqual(-15.0, p.DECsky = -15.0);
            Assert.AreEqual(+105.0, p.DECm);

            Assert.AreEqual(-225.0, p.DECm = -225.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
            Assert.AreEqual(-45.0, p.DECsky);
            Assert.AreEqual(-45.0, p.DECsky = -45.0);
            Assert.AreEqual(+135.0, p.DECm);

            Assert.AreEqual(-180.0, p.DECm = -180.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);
            Assert.AreEqual(-90.0, p.DECsky);
            Assert.AreEqual(-90.0, p.DECsky = -90.0);
            Assert.AreEqual(-180.0, p.DECm);

            Assert.AreEqual(-135.0, p.DECm = -135.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);
            Assert.AreEqual(-45.0, p.DECsky);
            Assert.AreEqual(-45.0, p.DECsky = -45.0);
            Assert.AreEqual(-135.0, p.DECm);

            Assert.AreEqual(-90.0, p.DECm = -90.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);
            Assert.AreEqual(+0.0, p.DECsky);
            Assert.AreEqual(+0.0, p.DECsky = +0.0);
            Assert.AreEqual(-90.0, p.DECm);

            Assert.AreEqual(-45.0, p.DECm = -45.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);
            Assert.AreEqual(+45.0, p.DECsky);
            Assert.AreEqual(+45.0, p.DECsky = +45.0);
            Assert.AreEqual(-45.0, p.DECm);

            Assert.AreEqual(+0.0, p.DECm = +0.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
            Assert.AreEqual(+90.0, p.DECsky);
            Assert.AreEqual(+90.0, p.DECsky = +90.0);
            Assert.AreEqual(+0.0, p.DECm);

            Assert.AreEqual(+45.0, p.DECm = +45.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
            Assert.AreEqual(+45.0, p.DECsky);
            Assert.AreEqual(+45.0, p.DECsky = +45.0);
            Assert.AreEqual(+45.0, p.DECm);

            Assert.AreEqual(+90.0, p.DECm = +90.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
            Assert.AreEqual(+0.0, p.DECsky);
            Assert.AreEqual(+0.0, p.DECsky = +0.0);
            Assert.AreEqual(+90.0, p.DECm);

            Assert.AreEqual(+135.0, p.DECm = +135.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
            Assert.AreEqual(-45.0, p.DECsky);
            Assert.AreEqual(-45.0, p.DECsky = -45.0);
            Assert.AreEqual(+135.0, p.DECm);

            Assert.AreEqual(+180.0, p.DECm = +180.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_NORMAL, p.PointingState);
            Assert.AreEqual(-90.0, p.DECsky);
            Assert.AreEqual(-90.0, p.DECsky = -90.0);
            Assert.AreEqual(+180.0, p.DECm);

            Assert.AreEqual(+225.0, p.DECm = +225.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);
            Assert.AreEqual(-45.0, p.DECsky);
            Assert.AreEqual(-45.0, p.DECsky = -45.0);
            Assert.AreEqual(-135.0, p.DECm);

            Assert.AreEqual(+255.0, p.DECm = +255.0);
            Assert.AreEqual(MechanicalPoint.PointingStates.POINTING_BEYOND_POLE, p.PointingState);
            Assert.AreEqual(-15.0, p.DECsky);
            Assert.AreEqual(-15.0, p.DECsky = -15.0);
            Assert.AreEqual(-105.0, p.DECm);
        }