/// <summary>
 /// Construct a OneTimeTearDownCommand
 /// </summary>
 /// <param name="suite">The test suite to which the command applies</param>
 /// <param name="setUpTearDown">A SetUpTearDownList for use by the command</param>
 public OneTimeTearDownCommand(TestSuite suite, SetUpTearDownList setUpTearDown)
     : base(suite)
 {
     if (suite.FixtureType != null)
         _tearDownMethods = Reflect.GetMethodsWithAttribute(suite.FixtureType, typeof(OneTimeTearDownAttribute), true);
     _setUpTearDown = setUpTearDown;
 }

 public virtual void Visit(TestSuite testSuite)
 {
     foreach (TestUnit child in testSuite.Children)
     {
         child.Apply(this);
     }
 }

        public void AssertTestCase_TestCaseError_StackTraceIsFilledWithXml()
        {
            var sut = "not empty string";
            var ctrStub = new Mock<Constraint>();
            ctrStub.Setup(c => c.Matches(It.IsAny<object>())).Throws(new ExternalDependencyNotFoundException("Filename"));
            var ctr = ctrStub.Object;

            var xmlContent = "<test><system></system><assert></assert></test>";

            var testSuite = new TestSuite();

            try
            {
                testSuite.AssertTestCase(sut, ctr, xmlContent);
            }
            catch (CustomStackTraceErrorException ex)
            {
                Assert.That(ex.StackTrace, Is.EqualTo(xmlContent));
            }
            catch (Exception ex)
            {
                if (ex.InnerException==null)
                    Assert.Fail("The exception should have been an CustomStackTraceErrorException but was {0}.\r\n{1}", new object[] { ex.GetType().FullName, ex.StackTrace });
                else
                    Assert.Fail("The exception should have been an CustomStackTraceErrorException but was something else. The inner exception is {0}.\r\n{1}", new object[] { ex.InnerException.GetType().FullName, ex.InnerException.StackTrace });
            }
        }

		public async Task TearDown (TestSuite suite)
		{
			if (!Persistent)
				await Server.Stop ();
			foreach (var extension in HttpClientTestFramework.Extensions)
				await extension.TearDown (suite);
		}

        public void TestCreatingTestSuiteForTestCase()
        {
            var suite = new TestSuite();
            suite.CreateTestSuiteFor(typeof(DummyTestCase));

            Assert.AreEqual(2, suite.Tests.Count);
        }

 public void TestFailsWhenDerivedExceptionIsThrown()
 {
     TestSuite suite = new TestSuite(typeof(DerivedExceptionThrownClass));
     TestResult result = (TestResult)suite.Run().Results[0];
     Assert.That(result.ResultState, Is.EqualTo(ResultState.Failure));
     Assert.That(result.Message, Is.EqualTo("Expected Exception of type <System.Exception>, but was <System.ApplicationException>"));
 }

        /// <summary>
        /// Gets the command to be executed before any of
        /// the child tests are run.
        /// </summary>
        /// <returns>A TestCommand</returns>
        public static TestCommand MakeOneTimeSetUpCommand(TestSuite suite, List<SetUpTearDownItem> setUpTearDown, List<TestActionItem> actions)
        {
            // Handle skipped tests
            if (suite.RunState != RunState.Runnable && suite.RunState != RunState.Explicit)
                return MakeSkipCommand(suite);

            // Build the OneTimeSetUpCommand itself
            TestCommand command = new OneTimeSetUpCommand(suite, setUpTearDown, actions);

            // Prefix with any IApplyToContext items from attributes
            IList<IApplyToContext> changes = null;

            if (suite.TypeInfo != null)
                changes = suite.TypeInfo.GetCustomAttributes<IApplyToContext>(true);
            else if (suite.Method != null)
                changes = suite.Method.GetCustomAttributes<IApplyToContext>(true);
            else
            {
                var testAssembly = suite as TestAssembly;
                if (testAssembly != null)
#if PORTABLE
                    changes = new List<IApplyToContext>(testAssembly.Assembly.GetAttributes<IApplyToContext>());
#else
                    changes = (IApplyToContext[])testAssembly.Assembly.GetCustomAttributes(typeof(IApplyToContext), true);
#endif
            }

            if (changes != null && changes.Count > 0)
                command = new ApplyChangesToContextCommand(command, changes);

            return command;
        }

	public static TestSuite Suite()
			{
				TestSuite suite = new TestSuite("Security Tests");
				suite.AddTests(typeof(TestSecurityExceptions));
				suite.AddTests(typeof(TestSecurityElement));
				return suite;
			}

    /**
     * Initialize class resources.
     */
    void Start()
    {
        // Create test suite
        TestSuite suite = new TestSuite();

        // For each assembly in this app domain
        foreach (Assembly assem in AppDomain.CurrentDomain.GetAssemblies())
        {
            // For each type in the assembly
            foreach (Type type in assem.GetTypes())
            {
                // If this is a valid test case
                // i.e. derived from TestCase and instantiable
                if (typeof(TestCase).IsAssignableFrom(type) &&
                    type != typeof(TestCase) &&
                    !type.IsAbstract)
                {
                    // Add tests to suite
                    suite.AddAll(type.GetConstructor(new Type[0]).Invoke(new object[0]) as TestCase);
                }
            }
        }

        // Run the tests
        TestResult res = suite.Run(null);

        // Report results
        Unity3D_TestReporter reporter = new Unity3D_TestReporter();
        reporter.LogResults(res);
    }

        /// <summary>
        /// Gets the command to be executed before any of
        /// the child tests are run.
        /// </summary>
        /// <returns>A TestCommand</returns>
        public static TestCommand MakeOneTimeSetUpCommand(TestSuite suite, List<SetUpTearDownItem> setUpTearDown, List<TestActionItem> actions)
        {
            // Handle skipped tests
            if (suite.RunState != RunState.Runnable && suite.RunState != RunState.Explicit)
                return MakeSkipCommand(suite);

            // Build the OneTimeSetUpCommand itself
            TestCommand command = new OneTimeSetUpCommand(suite, setUpTearDown, actions);

            // Prefix with any IApplyToContext items from attributes
            if (suite.TypeInfo != null)
            {
                IApplyToContext[] changes = suite.TypeInfo.GetCustomAttributes<IApplyToContext>(true);
                if (changes.Length > 0)
                    command = new ApplyChangesToContextCommand(command, changes);
            }
            if (suite.Method!=null)
            {
                IApplyToContext[] changes = suite.Method.GetCustomAttributes<IApplyToContext>(true);
                if (changes.Length > 0)
                    command = new ApplyChangesToContextCommand(command, changes);
            }

            return command;
        }

	public static TestSuite Suite()
			{
				TestSuite suite = new TestSuite("Core Class Tests");
#if CONFIG_FRAMEWORK_2_0	
				suite.AddTests(typeof(TestActivationArguments));
				suite.AddTests(typeof(TestActivationContext));
				suite.AddTests(typeof(TestApplicationId));
				suite.AddTests(typeof(TestApplicationIdentity));
#endif
				suite.AddTests(typeof(TestArgIterator));
				suite.AddTests(typeof(TestArray));
				suite.AddTests(typeof(TestAttribute));
				suite.AddTests(typeof(TestBoolean));
				suite.AddTests(typeof(TestConvert));
				suite.AddTests(typeof(TestDecimal));
				suite.AddTests(typeof(TestDelegate));
				suite.AddTests(typeof(TestDouble));
				suite.AddTests(typeof(TestSByte));
				suite.AddTests(typeof(TestString));
			#if !ECMA_COMPAT
				suite.AddTests(typeof(TestGuid));
			#endif
				suite.AddTests(typeof(TestSystemExceptions));
				suite.AddTests(typeof(TestVersion));
				return suite;
			}

        public void AddChildToTestCase()
        {
            TestSuite master = new TestSuite("master", null);
            TestCase test = new TestCase("test", master);

            test.AddChild(new TestCase());
        }

        private static void BenchmarkStringJoin(string[] testData, string expectedData)
        {
            var testName = String.Format("Joining strings - with {0} string", testData.Length);

            // Create a TestSuite class for a group of BenchmarTests
            var benchmarkSuite = new TestSuite<string[], string>(testName)
                                    // You don't have to specify a method group - but you'll probably want to give an explicit name if you use
                                    .Plus(input => String.Join(" ", input), "String.Join")
                                    .Plus(LoopingWithStringBuilderCommumUsage)
                                    .Plus(input => LoopingWithStringBuilderWithInitialCapacity(input, expectedData.Length + 2), "LoopingWithStringBuilderWithInitialCapacity")
                                    .Plus(LoopingWithStringBuilderWithInitialValue)
                                    .Plus(input => LoopingWithStringBuilderWithInitialValueAndCapacity(input, expectedData.Length + 2), "LoopingWithStringBuilderWithInitialValueAndCapacity")
                                    .Plus(LoopingWithStringConcatenation)
                                    .Plus(LoopingWithStringConcat)
                                    .Plus(LoopingWithStringFormat);

            // This returns a ResultSuite
            var resultsSmallData = benchmarkSuite.RunTests(testData, expectedData)
                                        // Again, scaling returns a new ResultSuite, with all the results scaled
                                        // - in this case they'll all have the same number of iterations
                                        .ScaleByBest(ScalingMode.VaryDuration);

            // There are pairs for name and score, iterations or duration - but we want name, duration *and* score
            resultsSmallData.Display(ResultColumns.NameAndDuration | ResultColumns.Score,
                                        // Scale the scores to make the best one get 1.0
                                        resultsSmallData.FindBest());
        }

 /// <summary>
 /// Constructs a OneTimeSetUpComand for a suite
 /// </summary>
 /// <param name="suite">The suite to which the command applies</param>
 public OneTimeSetUpCommand(TestSuite suite)
     : base(suite)
 {
     this.suite = suite;
     this.fixtureType = suite.FixtureType;
     this.arguments = suite.arguments;
 }

        public void AssertTestCase_TestCaseError_MessageIsAvailable()
        {
            var sut = "not empty string";
            var ctrStub = new Mock<Constraint>();
            ctrStub.Setup(c => c.Matches(It.IsAny<object>())).Throws(new ExternalDependencyNotFoundException("Filename"));
            var ctr = ctrStub.Object;

            var xmlContent = "<test><system></system><assert></assert></test>";

            var testSuite = new TestSuite();

            try
            {
                testSuite.AssertTestCase(sut, ctr, xmlContent);
            }
            catch (CustomStackTraceErrorException ex)
            {
                Console.WriteLine(ex.Message);
                Assert.That(ex.Message, Is.StringContaining("Filename"));
            }
            catch (Exception ex)
            {
                Assert.Fail("The exception should have been a CustomStackTraceErrorException but was {0}.", new object[] { ex.GetType().FullName });
            }
        }

        public static TestSuite suite()
        {
            TestSuite suite = new TestSuite();
            suite.AddTestSuite(typeof(IdentityTest));
            suite.AddTestSuite(typeof(AllTest));
            suite.AddTestSuite(typeof(FailTest));
            suite.AddTestSuite(typeof(OneTest));
            suite.AddTestSuite(typeof(FailAtNodesTest));
            suite.AddTestSuite(typeof(SomeTest));
            suite.AddTestSuite(typeof(TopDownUntilTest));
            suite.AddTestSuite(typeof(SpineBottomUpTest));
            suite.AddTestSuite(typeof(SpineTopDownTest));
            suite.AddTestSuite(typeof(SuccessCounterTest));
            suite.AddTestSuite(typeof(IfThenElseTest));
            suite.AddTestSuite(typeof(AllSpinesBottomUpTest));
            suite.AddTestSuite(typeof(ChildTest));
            suite.AddTestSuite(typeof(CollectTest));
            suite.AddTestSuite(typeof(DescendantTest));
            suite.AddTestSuite(typeof(DoWhileSuccessTest));
            suite.AddTestSuite(typeof(LoggerTest));
            suite.AddTestSuite(typeof(NestingDepthTest));
            suite.AddTestSuite(typeof(OnceTopDownTest));
            suite.AddTestSuite(typeof(TimeLogVisitorTest));
            suite.AddTestSuite(typeof(LibraryTest));

            return suite;
        }

		protected override void OnCreate (Bundle bundle)
		{
			base.OnCreate (bundle);

			test_suite = Intent.GetStringExtra ("TestSuite");
			suite = AndroidRunner.Suites [test_suite];

			var menu = new RootElement (String.Empty);
			
			main = new Section (test_suite);
			foreach (ITest test in suite.Tests) {
				TestSuite ts = test as TestSuite;
				if (ts != null)
					main.Add (new TestSuiteElement (ts));
				else
					main.Add (new TestCaseElement (test as NUnit.Framework.Internal.Test));
			}
			menu.Add (main);

			Section options = new Section () {
				new ActionElement ("Run all", Run),
			};
			menu.Add (options);

			var da = new DialogAdapter (this, menu);
			var lv = new ListView (this) {
				Adapter = da
			};
			SetContentView (lv);
		}

		void Build (TestSuite suite)
		{
//			if (Environment.GetEnvironmentVariables().Contains("START_DEBUG"))
//				System.Diagnostics.Debugger.Launch ();
			ReadLists ();
			XmlDocument whole = new XmlDocument ();
			whole.Load (@"testsuite/TESTS/catalog-fixed.xml");

			foreach (XmlElement testCase in whole.SelectNodes ("test-suite/test-catalog/test-case")) {
				string testid = testCase.GetAttribute ("id");

				if (skipTargets.Contains (testid))
					continue;

				CatalogTestCase ctc = new CatalogTestCase(EnvOptions.OutputDir, testCase);
				if (!ctc.Process ())
					continue;

				SingleTestTransform stt = new SingleTestTransform (ctc);

				string expectedException = (string) expectedExceptions[testid];
				bool isKnownFailure = knownFailures.Contains (testid) || fixmeList.Contains (testid);

				suite.Add (new TestFromCatalog (testid, stt, expectedException,
					EnvOptions.InverseResults, isKnownFailure));
			}
		}

	public static TestSuite Suite()
			{
				TestSuite suite = new TestSuite("Collection Tests");
				suite.AddTests(typeof(TestArrayList));
				suite.AddTests(typeof(TestHashTable));
				return suite;
			}

		public TestSuiteElement (TestSuite suite, AndroidRunner runner) : base (suite, runner)
		{
			if (Suite.TestCaseCount > 0)
				Indicator = ">"; // hint there's more

            Caption = suite.FullName;
		}