Esempio n. 1
0
        private static void TestCodePattern(string testObject, int version, string pattern)
        {
            SWA_Ariadne_Model_MazeDimensionsAccessor dimensionsObj = SWA_Ariadne_Model_MazeDimensionsAccessor.Instance(version);
            SWA_Ariadne_Model_MazeCodeAccessor       codeObj       = SWA_Ariadne_Model_MazeCodeAccessor.Instance(version);

            Regex rx = new Regex(pattern);

            Random r        = new Random();
            int    minSize  = dimensionsObj.MinSize;
            int    maxXSize = dimensionsObj.MaxXSize;
            int    maxYSize = dimensionsObj.MaxYSize;

            for (int nTests = 0; nTests < 100; nTests++)
            {
                int  xSize = r.Next(minSize, maxXSize + 1);
                int  ySize = r.Next(minSize, maxYSize + 1);
                Maze maze  = new Maze(xSize, ySize, version);
                maze.CreateMaze();

                string codeValue = codeObj.Code(maze);

                Match m = rx.Match(codeValue);

                Assert.IsTrue(m.Success, testObject + " does not match expected pattern: " + pattern);
            }
        }
Esempio n. 2
0
        public void M_ConstructorTest_size_02()
        {
            string testObject = "Maze.Constructor(size)-02-max";
            int    version    = 0;
            SWA_Ariadne_Model_MazeDimensionsAccessor dimensionsObj = SWA_Ariadne_Model_MazeDimensionsAccessor.Instance(version);
            int xSize         = int.MaxValue;
            int ySize         = int.MaxValue;
            int xSizeExpected = dimensionsObj.MaxXSize;
            int ySizeExpected = dimensionsObj.MaxYSize;

            ConstructorTestOutsideBounds(testObject, version, xSize, ySize, xSizeExpected, ySizeExpected);
        }
Esempio n. 3
0
        public void MD_InstanceTest_02()
        {
            string testObject = "MazeDimensions.Instance(1)";
            int    version    = 1;

            SWA_Ariadne_Model_MazeDimensionsAccessor target = SWA_Ariadne_Model_MazeDimensionsAccessor.Instance(version);

            int expected, actual;

            expected = 424; // manually calculated
            actual   = target.MaxXSize;
            Assert.AreEqual(expected, actual, testObject + ": wrong MaxXSize value");

            expected = 318; // manually calculated
            actual   = target.MaxYSize;
            Assert.AreEqual(expected, actual, testObject + ": wrong MaxYSize value");
        }
Esempio n. 4
0
        private static void TestDecodeIdentity(string testObject, int version)
        {
            SWA_Ariadne_Model_MazeDimensionsAccessor dimensionsObj = SWA_Ariadne_Model_MazeDimensionsAccessor.Instance(version);
            SWA_Ariadne_Model_MazeCodeAccessor       codeObj       = SWA_Ariadne_Model_MazeCodeAccessor.Instance(version);

            Random r = new Random();

            for (int nTests = 0; nTests < 100; nTests++)
            {
                int  xSize = r.Next(dimensionsObj.MinSize, dimensionsObj.MaxXSize + 1);
                int  ySize = r.Next(dimensionsObj.MinSize, dimensionsObj.MaxYSize + 1);
                Maze maze  = new Maze(xSize, ySize, version);
                maze.CreateMaze();

                SWA_Ariadne_Model_MazeAccessor accessor = new SWA_Ariadne_Model_MazeAccessor(maze);
                int          seed      = accessor.seed;
                WallPosition direction = accessor.direction;
                int          xStart    = accessor.xStart;
                int          yStart    = accessor.yStart;
                int          xEnd      = accessor.xEnd;
                int          yEnd      = accessor.yEnd;

                string code = maze.Code;

                int seedActual, xSizeActual, ySizeActual;
                codeObj.Decode(code
                               , out seedActual
                               , out xSizeActual, out ySizeActual
                               );

                bool ok = true;
                ok &= (seed == seedActual);
                ok &= (xSize == xSizeActual);
                ok &= (ySize == ySizeActual);

                if (!ok)
                {
                    ok = false;
                }

                Assert.AreEqual(seed, seedActual, testObject + ": seed was not set correctly.");
                Assert.AreEqual(xSize, xSizeActual, testObject + ": xSize was not set correctly.");
                Assert.AreEqual(ySize, ySizeActual, testObject + ": ySize was not set correctly.");
            }
        }
Esempio n. 5
0
        public void MD_MaxSizeTest_01()
        {
            string testObject = "MazeDimensions.MaxXSize and MazeDimensions.MaxYSize (version 0)";
            int    version    = 0;
            SWA_Ariadne_Model_MazeDimensionsAccessor dimensionsObj = SWA_Ariadne_Model_MazeDimensionsAccessor.Instance(version);
            SWA_Ariadne_Model_MazeCodeAccessor       codeObj       = SWA_Ariadne_Model_MazeCodeAccessor.Instance(version);

            // simulate the multiplications executed in Maze.Code:

            double f1 = codeObj.SeedLimit;
            double f2 = dimensionsObj.MaxXSize - dimensionsObj.MinSize + 1;
            double f3 = dimensionsObj.MaxYSize - dimensionsObj.MinSize + 1;
            double f4 = dimensionsObj.MaxBorderDistance + 1;
            double f5 = dimensionsObj.MaxBorderDistance + 1;
            double f6 = dimensionsObj.MaxXSize + 1;
            double f7 = dimensionsObj.MaxXSize + 1;
            double f8 = (int)WallPosition.WP_NUM;

            double maxCodeValue = (f1 * f2 * f3 * f4 * f5 * f6 * f7 * f8) - 1;

            TestMaxCodeValue(testObject, maxCodeValue, codeObj.CodeLength, codeObj.CodeDigitRange);
        }