Exemple #1
0
        public void CreateInstance_should_be_callable_indirectly()
        {
            using (new IndirectionsContext())
            {
                // Arrange
                PEnvironment.GetFolderPathSpecialFolder().Body = folder => @"にゃんぱすー";

                // Act
                var actual = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);

                // Assert
                Assert.AreEqual("にゃんぱすー", actual);
            }
        }
Exemple #2
0
        public void RestartCurrentProcess_should_start_new_process_and_close_current_process()
        {
            using (new IndirectionsContext())
            {
                // Arrange
                var ms = new MockStorage(MockBehavior.Strict);
                PEnvironment.GetCommandLineArgs().BodyBy(ms).Expect(_ => _(), Times.Once()).Returns(new[] { "file name" });
                PEnvironment.CurrentDirectoryGet().BodyBy(ms).Expect(_ => _(), Times.Once()).Returns("current directory");

                var curProcMainMod = new PProxyProcessModule();
                curProcMainMod.AutoBodyBy(ms).
                Customize(m => m.
                          Do(curProcMainMod.FileNameGet).Expect(_ => _(curProcMainMod), Times.Once()).Returns("file path")
                          );

                var curProc = new PProxyProcess();
                curProc.StartInfoGet().BodyBy(ms).Expect(_ => _(curProc), Times.Once()).Returns(new ProcessStartInfo()
                {
                    UserName = "******"
                });
                curProc.MainModuleGet().BodyBy(ms).Expect(_ => _(curProc), Times.Once()).Returns(curProcMainMod);
                curProc.CloseMainWindow().BodyBy(ms).Expect(_ => _(curProc), Times.Once()).Returns(true);

                PProcess.GetCurrentProcess().BodyBy(ms).Expect(_ => _(), Times.Once()).Returns(curProc);
                PProcess.StartProcessStartInfo().BodyBy(ms).Expect(_ => _(It.Is <ProcessStartInfo>(x =>
                                                                                                   x.UserName == "urasandesu" &&
                                                                                                   x.UseShellExecute == true &&
                                                                                                   x.WorkingDirectory == "current directory" &&
                                                                                                   x.FileName == "file path"
                                                                                                   )), Times.Once()).Returns(new PProxyProcess());


                // Act
                var result = ULProcessMixin.RestartCurrentProcess();


                // Assert
                Assert.IsTrue(result);
                ms.Verify();
            }
        }
        public void NotifyStartJob_should_verify_using_the_methods_of_CommunicationContext_then_UpdateJobParameterFile()
        {
            using (new IndirectionsContext())
            {
                // Arrange
                // Set default behavior for most methods of Environment.
                PEnvironment.
                ExcludeGeneric().
                // Environment.CurrentManagedThreadId is used by Mock<T>.Setup<TResult>(Expression<Func<T, TResult>>).
                Exclude(PEnvironment.CurrentManagedThreadIdGet()).
                // Environment.OSVersion is used by Times.Once().
                Exclude(PEnvironment.OSVersionGet()).
                DefaultBehavior = IndirectionBehaviors.NotImplemented;

                var mockCtx = new Mock <CommunicationContext>();
                mockCtx.Setup(_ => _.VerifyRuntimeVersion(It.IsAny <string[]>())).Returns(0);
                mockCtx.Setup(_ => _.VerifyPrereqOf3rdParty(It.IsAny <string[]>())).Returns(0);
                mockCtx.Setup(_ => _.VerifyUserAuthority(It.IsAny <string[]>())).Returns(0);
                mockCtx.Setup(_ => _.VerifyProductLicense(It.IsAny <string[]>())).Returns(0);
                var ctx = mockCtx.Object;

                var args = new[] { "foo", "bar", "baz", "qux" };

                var mockUpdateJobParameterFile = new Mock <IndirectionAction <int, int, bool, string> >();
                PJobManager.UpdateJobParameterFileInt32Int32BooleanString().Body = mockUpdateJobParameterFile.Object;

                // Act
                JobManager.NotifyStartJob(ctx, args);

                // Assert
                mockCtx.Verify(_ => _.VerifyRuntimeVersion(args), Times.Once());
                mockCtx.Verify(_ => _.VerifyPrereqOf3rdParty(args), Times.Once());
                mockCtx.Verify(_ => _.VerifyUserAuthority(args), Times.Once());
                // VerifyProductLicense will never be called, so change verification Once() -> Never().
                mockCtx.Verify(_ => _.VerifyProductLicense(args), Times.Never());
                mockUpdateJobParameterFile.Verify(_ => _(0, 0, false, null), Times.Once());
            }
        }
Exemple #4
0
        private void HandleMessage(string returnData)
        {
            string[] lines = returnData.Split("|");
            Game     game  = GameManager.Game;

            lock (game)
            {
                if (lines.Length > 1)
                {
                    int maplines = int.Parse(lines[3]) * 3 + 4;
                    if (int.Parse(lines[0]) != game.Map.num)
                    {
                        game.Map.num  = int.Parse(lines[0]);
                        game.Map.Size = new Vector2f(int.Parse(lines[1]), int.Parse(lines[2]));
                        game.Map.Tiles.Clear();
                        game.Map.MapLayout.Clear();
                        for (int i = 0; i < int.Parse(lines[3]); i++)
                        {
                            game.Map.Tiles.Add(new Map.MapTileCenter(int.Parse(lines[4 + i * 3]),
                                                                     new Vector2f(int.Parse(lines[5 + i * 3]), int.Parse(lines[6 + i * 3]))));
                        }

                        game.Map.LoadTiles();
                    }

                    game.Pentities.Clear();
                    game.Pentities.Add(game.Characters[0]);
                    int entityLineNums = 0;
                    for (int i = 0; i < int.Parse(lines[maplines]); i++)
                    {
                        if (lines[entityLineNums + maplines + 1].Equals("Network"))
                        {
                            game.Characters[0].Position = new Vector2f(int.Parse(lines[entityLineNums + maplines + 4]),
                                                                       int.Parse(lines[entityLineNums + maplines + 5]));
                            game.Characters[0].Display.State.ID      = int.Parse(lines[entityLineNums + maplines + 6]);
                            game.Characters[0].Display.State.facing  = float.Parse(lines[entityLineNums + maplines + 7]);
                            game.Characters[0].Display.State.elapsed = Time.FromSeconds(float.Parse(lines[entityLineNums + maplines + 8]));
                            game.Characters[0].Experience            = int.Parse(lines[entityLineNums + maplines + 9]);
                            game.Characters[0].Experience            = int.Parse(lines[entityLineNums + maplines + 17]);
                            game.Characters[0].Experience            = int.Parse(lines[entityLineNums + maplines + 18]);
                            entityLineNums += 18;
                        }
                        else if (lines[entityLineNums + maplines + 1].Equals("PCharacter"))
                        {
                            PCharacter character = new PCharacter(lines[entityLineNums + maplines + 2], game);
                            character.Position = new Vector2f(int.Parse(lines[entityLineNums + maplines + 3]),
                                                              int.Parse(lines[entityLineNums + maplines + 4]));
                            character.Display.State.ID     = int.Parse(lines[entityLineNums + maplines + 5]);
                            character.Display.State.facing = float.Parse(lines[entityLineNums + maplines + 6]);
                            game.Pentities.Add(character);
                            entityLineNums += 17;
                        }
                        else if (lines[entityLineNums + maplines + 1].Equals("PProjectile"))
                        {
                            PProjectile projectile = new PProjectile(lines[entityLineNums + maplines + 2], game);
                            projectile.Position = new Vector2f(int.Parse(lines[entityLineNums + maplines + 3]),
                                                               int.Parse(lines[entityLineNums + maplines + 4]));
                            projectile.Display.State.ID     = int.Parse(lines[entityLineNums + maplines + 5]);
                            projectile.Display.State.facing = float.Parse(lines[entityLineNums + maplines + 6]);
                            entityLineNums += 7;
                        }
                        else if (lines[entityLineNums + maplines + 1].Equals("PEnvironment"))
                        {
                            PEnvironment environment = new PEnvironment(lines[entityLineNums + maplines + 2], game);
                            environment.Position = new Vector2f(int.Parse(lines[entityLineNums + maplines + 3]),
                                                                int.Parse(lines[entityLineNums + maplines + 4]));
                            environment.Display.State.ID     = int.Parse(lines[entityLineNums + maplines + 5]);
                            environment.Display.State.facing = float.Parse(lines[entityLineNums + maplines + 6]);
                            game.Pentities.Add(environment);
                            entityLineNums += 7;
                        }
                    }
                }
            }
        }
 public static MockStorage AutoBodyBy(MockStorage ms)
 {
     { var m = PEnvironment.GetCommandLineArgs().BodyBy(ms); m.Setup(_ => _()).Returns(new[] { Guid.NewGuid().ToString() }); ms.Set(PEnvironment.GetCommandLineArgs, m); }
     { var m = PEnvironment.CurrentDirectoryGet().BodyBy(ms); m.Setup(_ => _()).Returns(Guid.NewGuid().ToString()); ms.Set(PEnvironment.CurrentDirectoryGet, m); }
     return(ms);
 }