/// <summary>
        /// Strong Contruction
        /// </summary>
        /// <param name="map">Map to solve</param>
        public SolverController(SokobanMap map)
        {
            if (map == null) throw new ArgumentNullException("map");
            this.settings = new Settings();

            this.state = States.NotStarted;
            this.map = map;
            debugReport = new SolverReport();

            debugReport.AppendHeading(1, "SokoSolve | Solver Debug Report v{0}", ProgramVersion.VersionString);

            debugReport.Append("Creating Statistics");
            stats = new SolverStats(this);
            debugReport.Append("Creating Exit Conditions");
            exitConditions = new ItteratorExitConditions();

            // TODO: This should be configured, perhaps via a factory pattern
            debugReport.Append("Creating Forward Strategy");
            strategy = new SolverStrategy(this);
            debugReport.Append("Creating Forward Evaluator");
            evaluator = new Evaluator<SolverNode>(true);

            debugReport.Append("Creating Reverse Strategy");
            reverseStrategy = new ReverseStrategy(this);
            debugReport.Append("Creating Reverse Evaluator");
            reverseEvaluator = new Evaluator<SolverNode>(true);
        }
        public void TestReverseStrategyCoreSimple()
        {
            CodeTimer timer = new CodeTimer("");
            timer.Start();

            try
            {
                SokobanMap map = new SokobanMap();
                map.SetFromStrings(new string[]
                                   {
             "~##~#####",
              "##.##.O.#",
              "#.##.XO.#",
              "~##.X...#",
              "##.XP.###",
              "#.X..##~~",
              "#OO.##.##",
              "#...#~##~",
              "#####~#~~"
                                   });

                PuzzleMap pMap = new PuzzleMap((Puzzle)null);
                pMap.Map = map;

                SolverController controller = new SolverController(pMap);
                controller.Init();
                controller.State = SolverController.States.Running; // Manually set state, as we are not using the controller; but the strategy uses the controller to check if it should exit

                ReverseStrategy rev = new ReverseStrategy(controller);

                Evaluator<SolverNode> eval = new Evaluator<SolverNode>();
                EvalStatus result =  eval.Evaluate(rev);

                Assert.AreEqual(EvalStatus.CompleteSolution, result, "Should find a solution");
            }
            finally
            {
                timer.Stop();
                System.Console.WriteLine("Total Time: " + timer.Duration(1));
            }
        }
        ///<summary>
        ///Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        ///</summary>
        ///<filterpriority>2</filterpriority>
        public void Dispose()
        {
            if (reverseWorker != null)
            {
                if (reverseWorker.IsAlive) reverseWorker.Join(100);
                reverseWorker = null;
            }

            if (strategy != null)
            {
                strategy.Dispose();
                strategy = null;
            }
            if (evaluator != null)
            {
                evaluator.Dispose();
                evaluator = null;
            }
            if (reverseEvaluator != null)
            {
                reverseEvaluator.Dispose();
                reverseEvaluator = null;
            }
            if (reverseStrategy != null)
            {
                reverseStrategy.Dispose();
                reverseStrategy = null;
            }
            if (stats != null)
            {
                stats.Clear();
                stats.Dispose();
                stats = null;
            }
        }