public void NUnitExecute()
        {
            #region Find NUnit installation
            string nunitPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
            nunitPath = Path.Combine(nunitPath, NUnit.DEFAULT_NUNIT_DIRECTORY);

            RegistryKey buildKey = Registry.ClassesRoot.OpenSubKey(@"NUnitTestProject\shell\open\command");
            if (buildKey == null) Assert.Ignore(@"Can't find NUnit installation");

            nunitPath = buildKey.GetValue(null, nunitPath).ToString();
            Regex nunitRegex = new Regex("(.+)nunit-gui\\.exe", RegexOptions.IgnoreCase);
            Match pathMatch = nunitRegex.Match(nunitPath);
            nunitPath = pathMatch.Groups[1].Value.Replace("\"", "");

            #endregion Find NUnit installation

            MockBuild buildEngine = new MockBuild();

            string testDirectory = TaskUtility.makeTestDirectory(buildEngine);

            NUnit task = new NUnit();
            task.BuildEngine = buildEngine;
            task.Assemblies = TaskUtility.StringArrayToItemArray(
                Path.Combine(nunitPath, "nunit.framework.tests.dll"));
            task.WorkingDirectory = testDirectory;
            task.OutputXmlFile = Path.Combine(testDirectory, @"nunit.framework.tests-results.xml");
            Assert.IsTrue(task.Execute(), "Execute Failed");
        }

		public void LoadSettings(NUnit.Util.ISettings settings)
		{
			this.settings = settings;

			TabInfoCollection info = new TabInfoCollection();
			string tabList = (string)settings.GetSetting( Prefix + "TabList" );

			if ( tabList != null ) 
			{
				string[] tabNames = tabList.Split( new char[] { ',' } );
				foreach( string name in tabNames )
				{
					string prefix = Prefix + name;
					string text = (string)settings.GetSetting(prefix + ".Title");
					if ( text == null )
						break;

					TabInfo tab = new TabInfo( name, text );
					tab.Content = (TextDisplayContent)settings.GetSetting(prefix + ".Content", TextDisplayContent.Empty );
					tab.Enabled = settings.GetSetting( prefix + ".Enabled", true );
					info.Add( tab );
				}
			}

			if ( info.Count > 0 )		
				tabInfo = info;
			else 
				LoadDefaults();
		}

        /// <summary>
        /// Creates an NUnit assembly-level test.
        /// </summary>
        /// <param name="assembly">The assembly.</param>
        /// <param name="runner">The NUnit test runner.</param>
        public NUnitAssemblyTest(IAssemblyInfo assembly, NUnit.Core.TestRunner runner)
            : base(assembly.Name, assembly, runner.Test)
        {
            Kind = TestKinds.Assembly;

            this.runner = runner;
        }

		/// <summary>
		/// Method gets called once at the end of running the tests
		/// </summary>
		public override void AfterTest(NUnit.Framework.TestDetails testDetails)
		{
			if (Environment.OSVersion.Platform != PlatformID.Unix &&
				!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("BUILDAGENT_SUBKEY")))
			{
				// End redirection. Otherwise test might fail when we run them multiple
				// times in NUnit.
				RegOverridePredefKey(HKEY_CURRENT_USER, UIntPtr.Zero);
			}
			base.AfterTest(testDetails);
		}

		/// <summary>
		/// Method gets called once at the very start of running the tests
		/// </summary>
		public override void BeforeTest(NUnit.Framework.TestDetails testDetails)
		{
			base.BeforeTest(testDetails);

			if (Environment.OSVersion.Platform != PlatformID.Unix &&
				!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("BUILDAGENT_SUBKEY")))
			{
				UIntPtr hKey;
				RegCreateKey(HKEY_CURRENT_USER, TmpRegistryKey, out hKey);
				RegOverridePredefKey(HKEY_CURRENT_USER, hKey);
				RegCloseKey(hKey);
			}
		}

        public void SuiteFinished(NUnit.Core.TestResult result)
        {
            if(result.FullName.Equals(myRootName))
            {
                return;
            }

            JSONClass jsonClass = new JSONClass();
            jsonClass.Add("name", result.Name);
            jsonClass.Add("uuid", myUUID);
            jsonClass.Add("type", "SuiteFinished");

            ConsuloIntegration.SendToConsulo("unityTestState", jsonClass);
        }

 public void SuiteFinished(NUnit.Core.TestResult result)
 {
     if ((result.IsError || result.IsFailure) &&
         (result.FailureSite == FailureSite.SetUp || result.FailureSite == FailureSite.TearDown))
     {
         testLog.SendMessage(
             TestMessageLevel.Error,
             string.Format("{0} failed for test fixture {1}", result.FailureSite, result.FullName));
         if (result.Message != null)
             testLog.SendMessage(TestMessageLevel.Error, result.Message);
         if (result.StackTrace != null)
             testLog.SendMessage(TestMessageLevel.Error, result.StackTrace);
     }
 }

        public void SuiteStarted(NUnit.Core.TestName testName)
        {
            if(myRootName == null)
            {
                myRootName = testName.FullName;
                return;
            }

            JSONClass jsonClass = new JSONClass();
            jsonClass.Add("uuid", myUUID);
            jsonClass.Add("name", testName.Name);
            jsonClass.Add("type", "SuiteStarted");

            ConsuloIntegration.SendToConsulo("unityTestState", jsonClass);
        }

        public override void WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter writer)
        {
            int lines = Math.Min(expectedLines.Length, actualLines.Length);
            for (int i = 0; i < lines; i++)
            {
                string expectedLine = expectedLines[i];
                string actualExLine = actualLines[i];
                if (!(expectedLine.Equals(actualExLine)))
                {
                    writer.WriteActualValue(actualExLine + ", line " + (i + 1).ToString() + Environment.NewLine + expected);
                    return;
                }

            }

            writer.WriteActualValue("actual text is " + actualLines.Length + " lines");
        }

        /// <summary>
        /// The delegate to handle the message box is installed.
        /// </summary>
        /// <param name="cmd">Contains a NUnit.Extensions.Forms.MessageBoxTester.Command to
        /// insert the desired reaction.</param>
        public void WaitForMessageBox(NUnit.Extensions.Forms.MessageBoxTester.Command cmd)
        {
            lastMessageTitle = "";
            lastMessageText = "";

            ModalFormHandler = delegate(string name, IntPtr hWnd, Form form)
            {
                MessageBoxTester tester = new MessageBoxTester(hWnd);

                System.Console.WriteLine("Title: " + tester.Title);
                System.Console.WriteLine("Message: " + tester.Text);

                lastMessageTitle = tester.Title;
                lastMessageText = tester.Text;

                tester.SendCommand(cmd);
            };
        }

        public void NUnitExecuteWhenToolPathIsDefined(int majorVersion, int minorVersion, int number)
        {
            string nUnitDirName = string.Format("NUnit {0}.{1}.{2}", majorVersion, minorVersion, number);
            string nunitPath = Path.Combine(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), nUnitDirName), "bin");
            if (!Directory.Exists(nunitPath))
            {
                Assert.Inconclusive("{0} - not found", nunitPath);
            }

            MockBuild buildEngine = new MockBuild();
            string testDirectory = TaskUtility.makeTestDirectory(buildEngine);

            NUnit task = new NUnit();
            task.ToolPath = nunitPath;
            task.BuildEngine = buildEngine;
            task.Assemblies = TaskUtility.StringArrayToItemArray(Path.Combine(nunitPath, "nunit.framework.tests.dll"));
            task.WorkingDirectory = testDirectory;
            Assert.IsTrue(task.Execute(), "Execute Failed");
        }

        public override void WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter writer)
        {
            if (expected == null || actualEx == null)
            {
                writer.WriteExpectedValue(expected);
            }
            else
            {
                int lines = Math.Min(expectedLines.Length, actualLines.Length);
                for (int i = 0; i < lines; i++)
                {
                    string expectedLine = expectedLines[i];
                    string actualExLine = actualLines[i];
                    if (!(expectedLine.Equals(actualExLine)))
                    {
                        writer.WriteExpectedValue(expectedLine);
                        return;
                    }
                }

                writer.WriteExpectedValue("expected text is " + expectedLines.Length + " lines");
            }
        }

		private UnitTestResult[] ParseTestList ( NUnit.Core.Test test, string currentAssemblyPath )
		{
			if (test.IsSuite)
			{
				var tests = new List<UnitTestResult> ();
				foreach (var obj in test.Tests)
				{
					if (obj is TestAssembly && File.Exists ((obj as TestAssembly).TestName.FullName))
						currentAssemblyPath = (obj as TestAssembly).TestName.FullName;

					if (obj is NUnit.Core.Test)
					{
						var results = ParseTestList (obj as NUnit.Core.Test, currentAssemblyPath);
						tests.AddRange (results);
					}
				}
				return tests.ToArray ();
			}
			else
			{
				return new[] { CreateNewTestResult (test as TestMethod, currentAssemblyPath) };
			}
		}

			public void SuiteFinished(NUnit.Core.TestResult result)
			{
			}

 public void RunFinished(NUnit.Core.TestResult result)
 {
 }

 public TestResult Run(NUnit.Framework.Internal.Test test)
 {
     TestExecutionContext current = TestExecutionContext.CurrentContext;
     current.WorkDirectory = System.Environment.CurrentDirectory;
     current.Listener = this;
     current.TestObject = test is TestSuite ? null : Reflect.Construct ((test as TestMethod).Method.ReflectedType, null);
     WorkItem wi = test.CreateWorkItem (Filter ?? TestFilter.Empty);
     if (test is TestMethod)
         (test.Parent as TestSuite).GetOneTimeSetUpCommand ().Execute (current);
     wi.Execute (current);
     if (test is TestMethod)
         (test.Parent as TestSuite).GetOneTimeTearDownCommand ().Execute (current);
     return wi.Result;
 }

		public void Write( NUnit.Core.TestOutput output )
		{
			Write( output.Text );
		}

		private void UpdateTestResults(NUnit.Core.TestResult result)
		{
			ToUnitTestResult(result);
		}

 public override void WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter writer)
 {
     writer.WriteActualValue(actualValue);
 }

		private void events_TestUnloaded(object sender, NUnit.Util.TestEventArgs args)
		{
			availableCategories.Clear();
			availableList.Items.Clear();
			selectedList.Items.Clear();
			excludeCheckbox.Checked = false;
			excludeCheckbox.Enabled = false;
			treeMenu.Visible = false;
		}