public void ShouldRunBatchFileBeforeRunningTargets()
        {
            UnzipSolution();

            FileSystemTestHelper.RecreateDirectory(@"BeforeBounceFeature\bounce");

            //as there is a circular dependancy between BeforeBounceFeature.sln and the main bounce dll's
            //this needs to be run and built under the same framework version
            #if (FRAMEWORKV35)
            File.WriteAllText(@"BeforeBounceFeature\bounce\beforebounce.bat", @"%SystemRoot%\Microsoft.NET\Framework\v3.5\msbuild.exe BeforeBounceFeature.sln /p:Configuration=Debug_3_5");
            #else
            File.WriteAllText(@"BeforeBounceFeature\bounce\beforebounce.bat", @"%SystemRoot%\Microsoft.NET\Framework\v4.0.30319\msbuild.exe BeforeBounceFeature.sln");
            #endif

            var shell = new Shell(new FakeLog());

            ProcessOutput output = null;

            FileSystemUtils.Pushd(@"BeforeBounceFeature", () => output = shell.Exec(@"..\bounce.exe", "BeforeBounceFeature"));

            Assert.That(output, Is.Not.Null);
            Assert.That(output.ExitCode, Is.EqualTo(0));
            Assert.That(output.Error.Trim(), Is.EqualTo(""));
            Assert.That(output.Output, Is.StringContaining("building before bounce feature"));
        }

    public static void Main()
    {
        var shell = new Shell();
        string cmd = string.Empty;
        while(true)
        {
            Console.Write("> ");
            cmd = Console.ReadLine();
            if(cmd == null || cmd == "quit" || cmd == "exit")
            {
                return;
            }

            try
            {
                var success = shell.Command(cmd);
                if(!success)
                {
                    Console.WriteLine("Invalid command " + cmd);
                }
            }
            catch(Exception ex)
            {
                Console.WriteLine(cmd);
                Console.WriteLine(ex);
            }
        }
    }

        protected override DependencyObject CreateShell()
        {
            Shell shell = new Shell();
            shell.Show();

            return shell;
        }

 public FileUploadOrDownload(IHost host, Shell shellData, string sourceFilePath, string targetFilePath)
 {
     _host = host;
     _shellData = shellData;
     _sourceFilePath = sourceFilePath;
     _targetFilePath = targetFilePath;
 }

        public PanelDbManager(IHost host, PluginParameter data)
        {
			_host = host;
			_shellData = (Shell)data[0];
			_shellSqlConn = GetShellSqlConn();

			// init StrRes to translate string
			StrRes.SetHost(_host);
            Init();			

            //绑定事件
			_dbManager = new DbManager(_host, _shellData, _shellSqlConn.type);
			_dbManager.ConnectDbCompletedToDo += DbManagerConnectDbCompletedToDo;
			_dbManager.GetDbNameCompletedToDo += DbManagerGetDbNameCompletedToDo;
			_dbManager.GetDbTableNameCompletedToDo += DbManagerGetTableNameCompletedToDo;
			_dbManager.GetColumnTypeCompletedToDo += DbManagerGetColumnTypeCompletedToDo;
			_dbManager.ExecuteReaderCompletedToDo += DbManagerExecuteReaderCompletedToDo;
			_dbManager.ExecuteNonQueryCompletedToDo += DbManagerExecuteNonQueryCompletedToDo;

			RefreshServerStatus(false);


	        if (string.IsNullOrEmpty(_shellSqlConn.type) || string.IsNullOrEmpty(_shellSqlConn.conn))
	        {
		        MessageBox.Show("shell's sqlConnection is null or space");
	        }
	        else
	        {
				//连接数据库
				_dbManager.ConnectDb(_shellSqlConn.conn);
	        }
        }

        public StreamingFindReferencesPresenter(
            Shell.SVsServiceProvider serviceProvider,
            ITextBufferFactoryService textBufferFactoryService,
            IProjectionBufferFactoryService projectionBufferFactoryService,
            IEditorOptionsFactoryService editorOptionsFactoryService,
            ITextEditorFactoryService textEditorFactoryService,
            IContentTypeRegistryService contentTypeRegistryService,
            ClassificationTypeMap typeMap,
            IEditorFormatMapService formatMapService,
            [ImportMany] IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> asyncListeners)
        {
            _serviceProvider = serviceProvider;
            _textBufferFactoryService = textBufferFactoryService;
            _projectionBufferFactoryService = projectionBufferFactoryService;
            _editorOptionsFactoryService = editorOptionsFactoryService;
            _contentTypeRegistryService = contentTypeRegistryService;

            _textEditorFactoryService = textEditorFactoryService;
            _typeMap = typeMap;
            _formatMapService = formatMapService;

            _asyncListener = new AggregateAsynchronousOperationListener(
                asyncListeners, FeatureAttribute.ReferenceHighlighting);

            _vsFindAllReferencesService = (IFindAllReferencesService)_serviceProvider.GetService(typeof(SVsFindAllReferences));
        }

        static void Main(string[] args) {

			Shell Dispatch = new Shell ();


				if (args.Length == 0) {
					throw new ParserException ("No command specified");
					}

                if (IsFlag(args[0][0])) {


                    switch (args[0].Substring(1).ToLower()) {
						case "mesh/recrypt server" : {
							Usage ();
							break;
							}
						case "start" : {
							Handle_Start (Dispatch, args, 1);
							break;
							}
						case "about" : {
							Handle_About (Dispatch, args, 1);
							break;
							}
						default: {
							throw new ParserException("Unknown Command: " + args[0]);
                            }
                        }
                    }
                else {
					Handle_Start (Dispatch, args, 0);
                    }
            } // Main

        public override void ModifyMetadata(Shell.ObjectEditing.ExtendedMetadata metadata, IEnumerable<Attribute> attributes)
        {
            base.ModifyMetadata(metadata, attributes);

            // We only want to select folders beneath the Gallery folder (163)
            metadata.EditorConfiguration["roots"] = new[] { new ContentReference(163) };
        }

        /// <summary>
        /// 	Initializes a new instance of the <see cref="TwiddlerApplication"/> class. 
        /// 	Launches an instance of Twiddler for testing.
        /// </summary>
        /// <param name="newStore">
        /// 	The new Store.
        /// </param>
        /// <returns>
        /// 	The launched instance.
        /// </returns>
        public TwiddlerApplication(bool newStore)
        {
            var args = new StringBuilder();

            args.Append(" /inMemory");
            args.AppendFormat(" /service={0}", DefaultService);

            string path = Path.GetFullPath(ApplicationPath);

            var startInfo = new ProcessStartInfo(path, args.ToString())
                                {
                                    UseShellExecute = false
                                };
            _application = Application.Launch(startInfo);

            try
            {
                Shell = new Shell(GetShellWindow());
            }
            catch (Exception)
            {
                if (!_application.HasExited)
                    _application.Kill();
                throw;
            }
        }

    //시작하면 스포너별 길찾기
    void FindPath()
    {
        //Assign StartNode and Goal Node
        for (int i = 0; i < 4; i++) {
            startNode[i] = new Shell (GridManager.instance.GetGridCellCenter (GridManager.instance.GetGridIndex (oStart [i].transform.position)));
        }
        goalNode = new Shell(GridManager.instance.GetGridCellCenter(GridManager.instance.GetGridIndex(oEnd.transform.position)));

        //pathArray = AStar.FindPath(startNode, goalNode);
        pathOneArray = AStar.FindPath(startNode[0], goalNode);
        pathTwoArray = AStar.FindPath(startNode[1], goalNode);
        pathThrArray = AStar.FindPath(startNode[2], goalNode);
        pathFourArray = AStar.FindPath(startNode[3], goalNode);

        /*pathOneArray = AStar2.Path(oStart [0].transform.position, oEnd.transform.position);
        foreach(Node i in pathOneArray){
            Debug.Log ("path :"+ i.pos.x +" "+ i.pos.y +" "+ i.pos.z);
        }
        pathTwoArray = AStar2.Path(oStart [1].transform.position, oEnd.transform.position);
        pathThrArray = AStar2.Path(oStart [2].transform.position, oEnd.transform.position);
        pathFourArray = AStar2.Path(oStart [3].transform.position, oEnd.transform.position);*/

        if(bStart == false)
            StartCoroutine ("MoveLeader");

        bStart = true;
    }

 public SolutionRunner(ILog log, AppSettings settings, PortReservations reservations, Shell shell)
 {
     _log = log;
     _settings = settings;
     _reservations = reservations;
     _shell = shell;
 }

        private double ScaleFactor; //Variable to hold the device scale factor (use to determine phone screen resolution)

        public Splash(SplashScreen splashscreen, Shell shell, bool loadState)
        {
            this.InitializeComponent();

            this.shell = shell;

            // Subscribe to changed size
            Window.Current.SizeChanged += new WindowSizeChangedEventHandler(Splash_OnResize);

            ScaleFactor = (double)DisplayInformation.GetForCurrentView().ResolutionScale / 100;

            splash = splashscreen;

            if (splash != null)
            {
                // Register an event handler to be executed when the splash screen has been dismissed.
                splash.Dismissed += new TypedEventHandler<SplashScreen, Object>(DismissedEventHandler);

                // Retrieve the window coordinates of the splash screen image.
                splashImageRect = splash.ImageLocation;
                PositionImage();
            }

            CheckMedDatabaseUpdateAsync();
        }

        private static void InvokeTestOptions(Shell shell, IShellCommand shellCommand, string[] args)
        {
            var prefixes = new[] { "--", "-", "/" };

            var optionsArgs = args
                .TakeWhile(x => prefixes.Any(p => x.StartsWith(p) && x.Length > p.Length))
                .ToList();

            var parser = new OptionSet();

            var options = (dynamic)new ExpandoObject();
            options.Verbosity = 0;

            parser
                .Add("c|config=", "Set config path", s => { if (!string.IsNullOrWhiteSpace(s)) options.ConfigPath = s; })
                .Add("v|verbose", "increase verbosity level", s => { if (s != null) options.Verbosity++; });

            var arguments = new List<string>(parser.Parse(optionsArgs));
            arguments.AddRange(args.Skip(optionsArgs.Count));

            options.Arguments = arguments;

            Console.WriteLine("Options:");
            Console.WriteLine(JsonConvert.SerializeObject(options, Formatting.Indented));
        }

		private static Shell ConvertCaiDaoDataRowToShell(DataRow row)
		{
			var shell = new Shell();

			shell.Id = row["ID"].ToString();
			shell.TargetId = row["Note"].ToString();
			shell.TargetLevel = row["TypeName"].ToString();
			shell.Status = "";

			shell.ShellUrl = row["SiteUrl"].ToString();
			shell.ShellPwd = row["SitePass"].ToString();
			shell.ShellType = GetScriptTypeById(Convert.ToInt32(row["nScript"].ToString()));
			shell.ShellExtraString = row["Config"].ToString();
			shell.ServerCoding = "UTF-8";
			shell.WebCoding = "UTF-8";

			shell.Area = "";
			shell.Remark = row["Note"].ToString();

			// convert time
			DateTime time;
			var success = DateTime.TryParse(row["AccessTime"].ToString(), out time);
			if (!success) time = DateTime.Now;
			var timeStr = time.Date.ToShortDateString();
			if (timeStr.Contains("/"))
			{
				timeStr = timeStr.Replace("/", "-");
			}
			shell.AddTime = timeStr;

			return shell;
		}

 public Shell(INavigationService navigationService)
 {
     Instance = this;
     this.InitializeComponent();
     MyHamburgerMenu.NavigationService = navigationService;
     VisualStateManager.GoToState(Instance, Instance.NormalVisualState.Name, true);
     LinkNavigationManager.Start();
 }

 public override Shell.Framework.Commands.CommandState QueryState(Shell.Framework.Commands.CommandContext context)
 {
     if ((context.Items == null) || (context.Items.Length != 1))
         return Shell.Framework.Commands.CommandState.Hidden;
     else
         // if single item selected.
         return base.QueryState(context);
 }

 public static void CloseShell()
 {
     if (shell != null)
     {
         shell.CloseSession();
         shell = null;
     }
 }

        public void SetUp()
        {
            var registry = new Registry();
            shell = new Shell();
            shell.Register(registry);

            container = new Container(registry);
        }

 public void Detect(Shell shell, Tank tank)
 {
     var hit = IsHit(shell.Point, tank.Target);
     if (hit)
     {
         _notifyHitMethod(tank.Owner, shell);
     }
 }

    public sType type; //셀의 타입

    #endregion Fields

    #region Constructors

    public Shell()
    {
        this.type = sType.NONE;
        this.estimatedCost = 0.0f;
        this.nodeTotalCost = 1.0f;
        this.bObstacle = false;
        this.parent = null;
    }