private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                // Use calculator by simulating clicks.
                String digitOne = this.comboBox1.SelectedItem.ToString();
                String digitTwo = this.comboBox2.SelectedItem.ToString();
                String operation = this.comboBox3.SelectedItem.ToString();

                WorkflowInvoker invoker = new WorkflowInvoker(ActivityXamlServices.Load(@"calc.uiwf"));
                var arguments = new Dictionary<string, object>();
                arguments.Add("digitOne", digitOne);
                arguments.Add("digitTwo", digitTwo);
                arguments.Add("op", operation);

                IDictionary<string, object> outArgs = invoker.Invoke(arguments);

                String sResult = (String)outArgs["calcResult"];
                this.textBox1.Text = sResult;
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, "ERROR: " + ex.Message);
            }
        }

        public void RunTestExtractAndConvertWorkflow_WhenRunningFullWorkflowShouldReplaceCorrectVersionNumbers()
        {
            // Create an instance of our test workflow
            var workflow = new TestExtractAndConvertWorkflowWrapper();

            // Create the workflow run-time environment
            var workflowInvoker = new WorkflowInvoker(workflow);

            var minuteCount = (int)DateTime.Now.TimeOfDay.TotalMinutes;

            workflowInvoker.Extensions.Add(new BuildDetailStub(minuteCount));

            // Set the workflow arguments
            workflow.ForceCreateVersion = true;
            workflow.AssemblyFileVersionReplacementPattern = "YYYY.MM.DD.B";
            workflow.BuildNumber = "TestCodeActivity - 2_20110310.3";
            workflow.AssemblyVersionReplacementPattern = "1.2.3.4";
            workflow.FolderToSearch = TestContext.DeploymentDirectory;
            workflow.FileSearchPattern = "AssemblyInfo.*";
            workflow.BuildNumberPrefix = 0;

            // Invoke the workflow and capture the outputs
            workflowInvoker.Invoke();

            var file = TestContext.DataRow[0].ToString();
            var versionName = TestContext.DataRow[1].ToString();

            var fileData = File.ReadAllText(file);
            var regexPattern = string.Format(SearchPatternShell, versionName);
            var regex = new Regex(regexPattern);
            var matches = regex.Matches(fileData);

            Assert.AreEqual(1, matches.Count);
        }

        public void GetVersionTestElapsed()
        {
            // Initialise Instance
            var target = new TfsVersion { Action = TfsVersionAction.GetVersion, VersionTemplateFormat = "0.0.1000.0", StartDate = Convert.ToDateTime("1 Mar 2009"), VersionFormat = TfsVersionVersionFormat.Elapsed, UseUtcDate = true };

            // Declare additional parameters
            var parameters = new Dictionary<string, object>
            {
                { "Major", "3" },
                { "Minor", "1" },
            };

            // Create a WorkflowInvoker and add the IBuildDetail Extension
            WorkflowInvoker invoker = new WorkflowInvoker(target);
            IBuildDetail t = new MockIBuildDetail { BuildNumber = "MyBuild_" + DateTime.Now.ToString("yyyyMMdd") + ".2" };
            t.BuildDefinition.Name = "MyBuild";
            invoker.Extensions.Add(t);

            var actual = invoker.Invoke(parameters);

            // Test the result
            DateTime d = Convert.ToDateTime("1 Mar 2009");
            TimeSpan ts = DateTime.Now - d;
            string days = ts.Days.ToString();
            Assert.AreEqual("3.1.1" + days + ".2", actual["Version"].ToString());
        }

 /// <summary>
 /// The Main program
 /// </summary>
 private static void Main()
 {
     var invoker = new WorkflowInvoker(Workflow1Definition);
     invoker.Extensions.Add(new WriteLineTracker());
     invoker.Extensions.Add(new FileTracker("Tracking.txt"));
     invoker.Invoke();
 }

        public void Can_choose_to_list_a_file_added_in_the_build_log()
        {
            // arrange
            var monitor = new DebugMonitor("Adding file to check");
            Trace.Listeners.Add(monitor);

            // create the activity
            var target = new StyleCop();

            // create a parameter set
            Dictionary<string, object> args = new Dictionary<string, object>
            {
                { "SourceFiles", new string[] { @"TestFiles\FileWith6Errors.cs" } },
                { "SettingsFile", @"TestFiles\AllSettingsEnabled.StyleCop" },
                { "ShowOutput", true }
            };

            // Create a WorkflowInvoker and add the IBuildDetail Extension
            WorkflowInvoker invoker = new WorkflowInvoker(target);

            // act
            var results = invoker.Invoke(args);

            // assert
            Assert.AreEqual(1, monitor.Writes);
        }

        public void Check_a_file_with_no_issues_and_defaults_rules_will_not_create_a_text_logfile()
        {
            // arrange
            var fileName = "LogFile.Txt";
            System.IO.File.Delete(fileName);

            // create the activity
            var target = new StyleCop();

            // create a parameter set
            Dictionary<string, object> args = new Dictionary<string, object>
            {
                 { "SourceFiles", new string[] { @"TestFiles\FileWith0Errors.cs" } },
                 { "SettingsFile", @"TestFiles\AllSettingsEnabled.StyleCop" },
                 { "LogFile", fileName }
            };

            // Create a WorkflowInvoker and add the IBuildDetail Extension
            WorkflowInvoker invoker = new WorkflowInvoker(target);

            // act
            var results = invoker.Invoke(args);

            // assert
            Assert.IsFalse(System.IO.File.Exists(fileName));
        }

        public void EmailTest()
        {
            // Initialise Instance
            var target = new TfsBuildExtensions.Activities.Communication.Email
                {
                    Action = EmailAction.Send,
                    EnableSsl = true,
                    FailBuildOnError = false,
                    Format = "HTML",
                    LogExceptionStack = true,
                    MailFrom = "YOUREMAIL",
                    Port = 587,
                    Priority = "Normal",
                    SmtpServer = "smtp.gmail.com",
                    Subject = "hi 2",
                    TreatWarningsAsErrors = false,
                    UseDefaultCredentials = false,
                    UserName = "YOUREMAIL",
                    UserPassword = "YOURPASSWORD"
                };
                
                // Declare additional parameters
            var parameters = new Dictionary<string, object>
            {
                { "MailTo", new[] { "YOURRECIPIENT" } },
            };

            // Create a WorkflowInvoker and add the IBuildDetail Extension
            WorkflowInvoker invoker = new WorkflowInvoker(target);
            var actual = invoker.Invoke(parameters);

            // note this unit test is for debugging rather than testing so just return a true assertion
            Assert.IsTrue(1 == 1);
        }

        public override bool Execute()
        {
            var url = GetCollectionUri();
            var binDir = GetBinariesDirectory();
            var teamBuildWorkflowAssemblyPath = GetTeamBuildWorkflowAssemblyDirectory();
            var pdbStrToolDirectory = GetPdbStrToolDirectory();

            LoadBuildWorkflowAssembly(teamBuildWorkflowAssemblyPath);

            LoadDbgHelpLibrary();
            ExtractPdbSrcExe(pdbStrToolDirectory);

            var collection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(url));

            var inputParameters = new Dictionary<string, object> { { "BinariesDirectory", binDir } };

            using (new IndexSourcesToolPathOverrideScope(pdbStrToolDirectory))
            {
                var workflow = new RunIndexSources();
                var invoker = new WorkflowInvoker(workflow);
                invoker.Extensions.Add(collection);
                invoker.Invoke(inputParameters);
            }

            return true;
        }

        public void ConvertVersionPattern_WhenUsingBuildPrefixShouldConvertIntoProperVersion()
        {
            var totalHours = (int)DateTime.Now.TimeOfDay.TotalHours;
            const int prefixVal = 100;

            // Create an instance of our test workflow
            var workflow = new Tests.ConvertVersionPatternTestWorkflow();

            // Create the workflow run-time environment
            var workflowInvoker = new WorkflowInvoker(workflow);

            workflowInvoker.Extensions.Add(new BuildDetailStub(totalHours));

            workflow.VersionPattern = "1.0.0.B";

            workflow.BuildNumberPrefix = prefixVal;

            // Invoke the workflow and capture the outputs
            var outputs = workflowInvoker.Invoke();

            // Retrieve the out arguments to do our verification
            var convertedVersionNumber = (String)outputs["ConvertedVersionNumber"];

            // Verify that we captured the version component of the build number
            Assert.AreEqual(string.Format("1.0.0.{0}", totalHours + prefixVal), convertedVersionNumber);
        }

        public void SmsTest()
        {
            // Initialise Instance
            var target = new TfsBuildExtensions.Activities.Communication.Sms
            {
                Action = SmsAction.Send,
                From = "YOUREMAIL",
                Body = "YOURBODY",
                AccountSid = "YOURSID",
                AuthToken = "YOURTOKEN"
            };

            // Declare additional parameters
            var parameters = new Dictionary<string, object>
            {
                { "To", new[] { "YOURRECIPIENT" } },
            };

            // Create a WorkflowInvoker and add the IBuildDetail Extension
            WorkflowInvoker invoker = new WorkflowInvoker(target);
            var actual = invoker.Invoke(parameters);

            // note this unit test is for debugging rather than testing so just return a true assertion
            Assert.IsTrue(1 == 1);
        }

        public void FileReplaceTest()
        {
            // Initialise Instance
            var target = new TfsBuildExtensions.Activities.FileSystem.File { Action = FileAction.Replace, RegexPattern = "Michael", Replacement = "Mike" };

            // Create a temp file and write some dummy attribute to it
            FileInfo f = new FileInfo(System.IO.Path.GetTempFileName());
            System.IO.File.WriteAllLines(f.FullName, new[] { "Michael" });

            // Declare additional parameters
            var parameters = new Dictionary<string, object>
            {
                { "Files", new[] { f.FullName } },
            };

            // Create a WorkflowInvoker and add the IBuildDetail Extension
            WorkflowInvoker invoker = new WorkflowInvoker(target);
            var actual = invoker.Invoke(parameters);

            // read the updated file back.
            using (System.IO.StreamReader file = new System.IO.StreamReader(f.FullName))
            {
                // Test the result
                Assert.AreEqual("Mike", file.ReadLine());
            }
        }

 public AsyncInvokeContext(object userState, WorkflowInvoker invoker)
 {
     this.UserState = userState;
     SynchronizationContext syncContext = SynchronizationContext.Current ?? System.Activities.WorkflowApplication.SynchronousSynchronizationContext.Value;
     this.Operation = new AsyncInvokeOperation(syncContext);
     this.Invoker = invoker;
 }

        public void Setting_the_cache_option_causes_the_results_to_be_cached_in_the_default_directory()
        {
            // arrange
            var resultsFile = "StyleCop.Cache";
            System.IO.File.Delete(resultsFile);

            // create the activity
            var target = new StyleCop();

            // create a parameter set
            Dictionary<string, object> args = new Dictionary<string, object>
            {
                 { "SourceFiles", new string[] { @"TestFiles\FileWith6Errors.cs" } },
                 { "SettingsFile", @"TestFiles\AllSettingsEnabled.StyleCop" },
                 { "CacheResults", true },
            };

            // Create a WorkflowInvoker and add the IBuildDetail Extension
            WorkflowInvoker invoker = new WorkflowInvoker(target);

            // act
            var results = invoker.Invoke(args);

            // assert
            Assert.IsTrue(System.IO.File.Exists(resultsFile));
            var document = new XPathDocument(resultsFile);
            var nav = document.CreateNavigator();
            Assert.AreEqual(6d, nav.Evaluate("count(/stylecopresultscache/sourcecode/violations/violation)"));
        }

        public virtual WorkflowResult RunWorkflow(string workflowName, Dictionary<string, object> parameters, object[] extensions = null)
        {
            var retVal = new WorkflowResult();
            parameters["ResultArgument"] = retVal;

            var activity = _activityProvider.GetWorkflowActivity(workflowName);
            if (activity == null)
            {
                throw new ArgumentException("Activity (workflow) not found by name: " + workflowName);
            }

            //var validationResults = ActivityValidationServices.Validate(activity);
            //if (validationResults.Errors.Count() == 0)
            //{
            var invoker = new WorkflowInvoker(activity);
            if (extensions != null)
            {
                foreach (var ext in extensions)
                {
                    invoker.Extensions.Add(ext);
                }
            }

            invoker.Invoke(parameters);

            //}
            //else
            //{
            //    throw new ValidationException();
            //}

            //ActivityInvoker.Invoke(activity, parameters, extensions);
            return retVal;
        }

        public void XmlFile_ValidateXmlTest()
        {
            // Arrange
            var target = new TfsBuildExtensions.Activities.Xml.Xml { Action = XmlAction.Transform };

            // Define activity arguments
            var arguments = new Dictionary<string, object>
            {
                { "XmlText", @"<?xml version=""1.0""?>
                    <catalog>
                       <book id=""bk101"">
                          <author>Gambardella, Matthew</author>
                          <title>XML Developer's Guide</title>
                          <genre>Computer</genre>
                          <price>44.95</price>
                          <publish_date>2000-10-01</publish_date>
                          <description>An in-depth look at creating applications 
                          with XML.</description>
                       </book>
                    </catalog>
                    " },
                { "XslTransform", @"<xsl:transform version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform""/>" },
            };

            // Act
            WorkflowInvoker invoker = new WorkflowInvoker(target);
            var result = invoker.Invoke(arguments);

            // Assert
            Assert.IsFalse((bool)result["IsValid"]);
        }

        public void Not_setting_the_cache_option_causes_the_results_to_not_be_cached_in_the_default_directory()
        {
            // arrange
            var resultsFile = "StyleCop.Cache";
            System.IO.File.Delete(resultsFile);

            // create the activity
            var target = new StyleCop();

            // create a parameter set
            Dictionary<string, object> args = new Dictionary<string, object>
            {
                 { "SourceFiles", new string[] { @"TestFiles\FileWith6Errors.cs" } },
                 { "SettingsFile", @"TestFiles\AllSettingsEnabled.StyleCop" },
                 { "CacheResults", false },
            };

            // Create a WorkflowInvoker and add the IBuildDetail Extension
            WorkflowInvoker invoker = new WorkflowInvoker(target);

            // act
            var results = invoker.Invoke(args);

            // assert
            Assert.IsFalse(System.IO.File.Exists(resultsFile));
        }

        public void Extra_rules_can_loaded_from_a_directory_that_is_not_a_sub_directory_of_current_location()
        {
            // arrange
            var resultsFile = "StyleCop.Cache";
            System.IO.File.Delete(resultsFile);

            // create the activity
            var target = new StyleCop();

            // create a parameter set
            Dictionary<string, object> args = new Dictionary<string, object>
            {
                 { "SourceFiles", new string[] { @"TestFiles\FileWith6Errors.cs" } },
                 { "SettingsFile", @"TestFiles\AllSettingsEnabled.StyleCop" },
                 { "AdditionalAddInPaths", new string[] { @"..\Activities.StyleCop.Tests\AddIns" } }, // the directory cannot be a sub directory of current as this is automatically scanned
              };

            // Create a WorkflowInvoker and add the IBuildDetail Extension
            WorkflowInvoker invoker = new WorkflowInvoker(target);

            // act
            var results = invoker.Invoke(args);

            // assert
            Assert.AreEqual(false, results["Succeeded"]);
            Assert.AreEqual(7, results["ViolationCount"]); // 6 core violations + the extra custom one
        }

 public void RunWorkflow()
 {
     var wf = new WorkflowInvoker( new CraigslistLeadCollector() );
       var result = wf.Invoke();
       Assert.IsInstanceOfType( result, typeof( Dictionary<string, object> ) );
       var element = result.ElementAt( 0 ).Value as XElement;
       element.Save("c:/temp/craigslistResponse.xml");
 }

 private void Because()
 {
     var validateLoanIsCompleteActivity = new WorkflowWebApiExample.CodeActivities.ValidateLoanIsComplete();
     var workflowInvoker = new WorkflowInvoker(validateLoanIsCompleteActivity);
     var InputArguments = new Dictionary<string, object>();
     InputArguments.Add("Loan", _loan);
     var resultDictionary = workflowInvoker.Invoke(InputArguments);
     _result = (bool)resultDictionary["Valid"];
 }

 private void Because()
 {
     var checkLoanEligibilityWorkflow = new WorkflowWebApiExample.Workflows.CheckLoanEligibility();
     var workflowInvoker = new WorkflowInvoker(checkLoanEligibilityWorkflow);
     var InputArguments = new Dictionary<string, object>();
     InputArguments.Add("loan", _loan);
     var resultDictionary = workflowInvoker.Invoke(InputArguments);
     _result = (bool)resultDictionary["approved"];
 }