public void RetrieveDescriptionOrNameRetrievesTheNameWhenDescriptionIsNotSet()
 {
     var task = new TestTask();
     task.Description = null;
     var actual = task.RetrieveDescriptionOrName();
     Assert.AreEqual(task.GetType().Name, actual);
 }

        public void SetUp()
        {
            _library = new GenericBTLibrary();

            _tree = new TestTask(null, "tree1", new ModelTask[0]);
            _tree2 = new TestTask(null, "tree2", new ModelTask[0]);
        }

 public void RunMinute()
 {
     var now = DateTime.UtcNow;
     var tt = new TestTask((byte)now.Hour, (sbyte)now.Minute);
     tt.Run();
     Assert.IsTrue(tt.Called);
 }

 public void RetrieveDescriptionOrNameRetrievesTheDescriptionWhenDescriptionIsSet()
 {
     var task = new TestTask();
     task.Description = "Test Task";
     var actual = task.RetrieveDescriptionOrName();
     Assert.AreEqual(task.Description, actual);
 }

 public void ValidateHandlesNull()
 {
     var task = new TestTask
     {
         Tasks = null
     };
     task.Validate(null, null, null);
 }

 public void ValidateHandlesEmpty()
 {
     var task = new TestTask
     {
         Tasks = new ITask[0]
     };
     task.Validate(null, null, null);
 }

 public void ApplyParametersHandlesNull()
 {
     var task = new TestTask
     {
         DynamicValues = null
     };
     var parameters = new Dictionary<string, string>();
     var definitions = new List<ParameterBase>();
     task.ApplyParameters(parameters, definitions);
 }

 internal override void Execute()
 {
     var cmdlet = (SendTmxTestTaskResultCommand)Cmdlet;
     var taskUpdater = new TaskUpdater(new RestRequestCreator());
     // 20140926
     // var testTask = new TestTask { TaskResult = new Dictionary<string, string>() };
     var testTask = new TestTask();
     foreach (var key in cmdlet.Result.Keys) {
         testTask.TaskResult.Add(key.ToString(), cmdlet.Result[key].ToString());
     }
     taskUpdater.SendTaskResult(testTask, ClientSettings.Instance.ClientId);
 }

        public void CascadeError() {
            var sw = new StringWriter();
            var t1 = new TestTask {DoError = true};
            var t2 = new TestTask(sw);
            t2.RequiredModules.Add(t1);
            t1.Execute();
            t2.Execute();
            Console.WriteLine(sw.ToString());
            Assert.AreEqual(@"
S:Pending
S:CascadeError
".Trim(), sw.ToString().Trim());
        }

        public void ValidateHandlesValidationTasks()
        {
            var subTask = new MockTask();
            var task = new TestTask
            {
                Tasks = new ITask[] 
                {
                    subTask
                }
            };

            task.Validate(null, ConfigurationTrace.Start(null), null);
            Assert.IsTrue(subTask.IsValided);
        }

        public void RunWithFalseResultMarksStatusAsFailed()
        {
            var task = new TestTask
            {
                Result = () => false
            };
            var result = mocks.DynamicMock<IIntegrationResult>();

            mocks.ReplayAll();
            task.Run(result);
            mocks.VerifyAll();

            Assert.IsTrue(task.Executed);
            Assert.AreEqual(ItemBuildStatus.CompletedFailed, task.CurrentStatus.Status);
        }

        public void ValidateHandlesNonValidationTasks()
        {
            var subTask = mocks.StrictMock<ITask>();
            var task = new TestTask
            {
                Tasks = new ITask[] 
                {
                    subTask
                }
            };

            mocks.ReplayAll();
            task.Validate(null, null, null);
            mocks.VerifyAll();
        }

 public void Execute_should_call_wait_for_exit_before_ExitCode()
 {
     //Since mono is broken and won't give us the ExitCode otherwise.
     var process = new ProcessStub();
     var waitForExitCalled = false;
     process.WaitForExitHandler = () => waitForExitCalled = true;
     process.GetExitCodeHandler = () =>
     {
         Assert.IsTrue(waitForExitCalled);
         return 0;
     };
     var platform = new ExecutionEnvironmentStub();
     platform.RunHandler = (program, args, handler) => handler(process);
     var task = new TestTask(platform);
     task.Execute();
 }

 internal override void Execute()
 {
     var cmdlet = (SendTmxTestTaskResultCommand)Cmdlet;
     // 20150918
     // var taskUpdater = new TaskUpdater(new RestRequestCreator());
     // var taskUpdater = new TaskUpdater();
     var taskUpdater = ProxyFactory.Get<TaskUpdater>();
     // 20140926
     // var testTask = new TestTask { TaskResult = new Dictionary<string, string>() };
     // 20150904
     var testTask = new TestTask();
     // TODO: parameterize this
     // var testTask = new TestTask(TestTaskRuntimeTypes.Powershell);
     foreach (var key in cmdlet.Result.Keys)
         testTask.TaskResult.Add(key.ToString(), cmdlet.Result[key].ToString());
     taskUpdater.SendTaskResult(testTask, ClientSettings.Instance.ClientId);
 }

        public void PreprocessParametersAddsDirectValueForValidAttributeDynamicValue()
        {
            var document = new XmlDocument();
            var xml = "<item attrib=\"$[value|default]\"><subItem>Text</subItem></item>";
            document.LoadXml(xml);

            var task = new TestTask();
            var actual = task.PreprocessParameters(new NetReflectorTypeTable(), document.DocumentElement);
            var expected = "<item attrib=\"default\"><subItem>Text</subItem>" +
                "<dynamicValues>" +
                    "<directValue>" +
                        "<parameter>value</parameter>" +
                        "<default>default</default>" +
                        "<property>attrib</property>" +
                    "</directValue>" +
                "</dynamicValues></item>";
            Assert.AreEqual(expected, actual.OuterXml);
        }

        public void ApplyParametersHandlesParameter()
        {
            var dynamicValue = mocks.StrictMock<IDynamicValue>();
            var task = new TestTask
            {
                DynamicValues = new IDynamicValue[]
                {
                    dynamicValue
                }
            };
            var parameters = new Dictionary<string, string>();
            var definitions = new List<ParameterBase>();
            Expect.Call(() =>
            {
                dynamicValue.ApplyTo(task, parameters, definitions);
            });

            mocks.ReplayAll();
            task.ApplyParameters(parameters, definitions);
            mocks.VerifyAll();
        }

        public void InitialiseStatusHandlesStatusTask()
        {
            var subTask = new MockTask();
            var task = new TestTask
            {
                Tasks = new ITask[] 
                {
                    subTask
                }
            };

            task.TestStatus();

            Assert.IsNotNull(task.CurrentStatus);
            Assert.IsTrue(subTask.SnapshotGenerated);
        }

 public void RunWrongMinute()
 {
     var now = DateTime.UtcNow;
     var minute = now.Minute > 1 ? now.Minute - 1 : 2;
     var tt = new TestTask((byte)now.Hour, (sbyte)minute);
     tt.Run();
     Assert.IsFalse(tt.Called);
 }

 public void RunWrongHour()
 {
     var now = DateTime.UtcNow;
     var hour = now.Hour > 1 ? now.Hour - 1 : 2;
     var tt = new TestTask((byte)hour);
     tt.Run();
     Assert.IsFalse(tt.Called);
 }

 public void MinuteMin()
 {
     var tt = new TestTask(1, sbyte.MinValue);
     Assert.AreEqual(-1, tt.Minute);
 }