public void resumeFromTaskTest()
        {
            SyncTriggerSystem system = createSystem();
            int i     = 0;
            var task1 = system.doTask(
                game => game.trigger.pauseTask(game.trigger.currentTask),
                game =>
            {
                Assert.AreEqual(1, game.trigger.currentTask.id);
                Assert.AreEqual(0, game.trigger.getPausedTasks().Length);
            },
                game => i++);

            Assert.AreEqual(1, task1.id);
            Assert.AreEqual(SyncTaskState.paused, task1.state);
            Assert.AreEqual(0, i);

            var task2 = system.doTask(
                game => game.trigger.resumeTask(task1),
                game => Assert.AreEqual(2, game.trigger.currentTask.id),
                game => i++);

            Assert.AreEqual(2, task2.id);
            Assert.AreEqual(2, i);
        }
        public void pauseResumeFromOtherTaskTreeTest()
        {
            SyncTriggerSystem system  = createSystem();
            SyncTask          taskUse = system.doTask("Use",
                                                      useAction1,
                                                      useAction2);

            void useAction1(CardEngine g1)
            {
                g1.trigger.doTask("Ask",
                                  askAction1,
                                  askAction2);
                void askAction1(CardEngine g2)
                {
                    g2.trigger.currentTask.parent.context["i"] = 1;
                }

                void askAction2(CardEngine g2)
                {
                    g2.trigger.pauseTask(g2.trigger.currentTask);
                }
            }

            void useAction2(CardEngine g1)
            {
                int i = g1.trigger.currentTask.context.getVar <int>(nameof(i));

                g1.trigger.currentTask.context.setVar(nameof(i), i * 2);
            }

            Assert.AreEqual(1, taskUse.context["i"]);
            Assert.AreEqual(1, system.getPausedTasks().Count());
            SyncTask taskSkill = system.doTask("Skill",
                                               skillAction1,
                                               skillAction2,
                                               skillAction3);

            void skillAction1(CardEngine g1)
            {
                g1.trigger.getPausedTasks()[0].parent.context["i"] = 2;
            }

            void skillAction2(CardEngine g1)
            {
                g1.trigger.resumeTask(g1.trigger.getPausedTasks()[0]);
            }

            void skillAction3(CardEngine g1)
            {
                g1.trigger.currentTask.context["j"] = 3;
            }

            Assert.AreEqual(4, taskUse.context["i"]);
            Assert.AreEqual(0, system.getPausedTasks().Count());
            Assert.AreEqual(3, taskSkill.context["j"]);
        }
        public void pauseAndResumeFromTaskTreeTest()
        {
            SyncTriggerSystem system = createSystem();
            SyncTask          task   = system.doTask("Use",
                                                     useAction1,//在AskTask暂停了
                                                     useAction2);

            void useAction1(CardEngine g1)
            {
                g1.trigger.doTask("Ask",
                                  askAction1,
                                  askAction2);
                void askAction1(CardEngine g2)
                {
                    g2.trigger.currentTask.parent.context["i"] = 1;
                }

                void askAction2(CardEngine g2)
                {
                    g2.trigger.pauseTask(g2.trigger.currentTask);
                }
            }

            void useAction2(CardEngine g1)
            {
                g1.trigger.currentTask.context["i"] = 2;
            }

            Assert.AreEqual(1, task.context["i"]);
            Assert.AreEqual(1, system.getPausedTasks().Count());
            system.resumeTask(system.getPausedTasks().First());
            Assert.AreEqual(2, task.context["i"]);
            Assert.AreEqual(0, system.getPausedTasks().Count());
        }
        public void stopTaskTest()
        {
            SyncTriggerSystem system = createSystem();
            int i    = 0;
            var task = system.doTask(
                game => i++,
                game => game.trigger.stopTask(game.trigger.currentTask),
                game => i++);

            Assert.AreEqual(SyncTaskState.finished, task.state);
            Assert.AreEqual(1, i);
        }
        public void taskTreeTest()
        {
            SyncTriggerSystem system = createSystem();
            int i    = 0;
            var task = system.doTask(
                g1 => g1.trigger.doTask(g2 => i++),
                g1 => g1.trigger.doTask(g2 => i++),
                g1 => g1.trigger.doTask(g2 => Assert.NotNull(g2.trigger.currentTask.parent)));

            Assert.AreEqual(3, task.getChildren().Length);
            Assert.AreEqual(2, i);
        }
        public void doTaskTest()
        {
            SyncTriggerSystem system = createSystem();
            int i = 0, j = 0, k = 0;
            var task = system.doTask(
                game => i = 1,
                game => j = 2,
                game => k = 3);

            Assert.NotNull(task);

            Assert.AreEqual(1, i);
            Assert.AreEqual(2, j);
            Assert.AreEqual(3, k);
        }
        public void pauseAndResumeTest()
        {
            SyncTriggerSystem system = createSystem();
            int i    = 0;
            var task = system.doTask(
                game => i++,
                game => i++,
                game => game.trigger.pauseTask(game.trigger.currentTask),
                game => i++);

            Assert.Null(system.currentTask);
            Assert.AreEqual(SyncTaskState.paused, task.state);
            Assert.AreEqual(task, system.getPausedTasks()[0]);
            Assert.AreEqual(2, i);

            system.resumeTask(task);

            Assert.AreEqual(SyncTaskState.finished, task.state);
            Assert.AreEqual(0, system.getPausedTasks().Length);
            Assert.AreEqual(3, i);
        }