public bool Filter(IFixture fixture, ITestCase test)
 {
     foreach (string scope in scopes)
         if (test.Name.ToLower().StartsWith(scope.ToLower()))
             return true;
     return false;
 }

 public TestFailed(ITestCase testCase, string testDisplayName, decimal executionTime, string output, string exceptionType, string message, string stackTrace)
     : base(testCase, testDisplayName, executionTime, output)
 {
     StackTrace = stackTrace;
     Message = message;
     ExceptionType = exceptionType;
 }

        private static VsTestCase Convert(
            ITestCase testcase,
            string shortName,
            string fullyQualifiedName,
            bool uniquifyNames)
        {
            string uniqueName;
            if (uniquifyNames)
                uniqueName = string.Format("{0}({1})", fullyQualifiedName, testcase.UniqueID);
            else
                uniqueName = fullyQualifiedName;

            var result = new VsTestCase();
            result.DisplayName = shortName;
            result.FullyQualifiedName = uniqueName;

            result.Id = GuidFromString(testcase.UniqueID);

            if (testcase.SourceInformation != null)
            {
                result.CodeFilePath = testcase.SourceInformation.FileName;
                result.LineNumber = testcase.SourceInformation.LineNumber;
            }

            return result;
        }

 public SetUpTearDownDecoratorTestCase(ITestCase testCase,
     MethodInfo setUpMethod, MethodInfo tearDownMethod)
     : base(testCase)
 {
     this.setUpMethod = setUpMethod;
     this.tearDownMethod = tearDownMethod;
 }

 public ExpectedExceptionTestCase(ITestCase testCase,Type exceptionType)
     : base(testCase)
 {
     if (exceptionType == null)
         throw new ArgumentNullException("exceptionType");
     this.exceptionType = exceptionType;
 }

        /// <inheritdoc/>
        public SourceInformation GetSourceInformation(ITestCase testCase)
        {
            return new SourceInformation();

            // TODO: Load DiaSession dynamically, since it's only available when running inside of Visual Studio.
            //       Or look at the CCI2 stuff from the Rx framework: https://github.com/Reactive-Extensions/IL2JS/tree/master/CCI2/PdbReader
        }

        public override TestResult DoTest(ITestCase testCase, int testCasesNumber, bool singleton)
        {
            var result = new TestResult { Singleton = singleton, TestCasesNumber = testCasesNumber };
            var sw = new Stopwatch();

            var c = new ServiceContainer();
            if (singleton)
            {
                sw.Start();
                c = (ServiceContainer)testCase.SingletonRegister(c);
                sw.Stop();
            }
            else
            {
                sw.Start();
                c = (ServiceContainer)testCase.TransientRegister(c);
                sw.Stop();
            }
            result.RegisterTime = sw.ElapsedMilliseconds;

            sw.Reset();
            result.ResolveTime = DoResolve(sw, testCase, c, testCasesNumber, singleton);

            c.Dispose();

            return result;
        }

        public bool SoSanh(string output, ITestCase testcase, out string message)
        {
            message = "";
            string[] s1Lines = output.Split('\n');
            string[] s2Lines = testcase.Output.Split('\n');
            int i = 0;
            while (i < s1Lines.Length && i < s2Lines.Length)
            {
                if (SoSanhLine(s1Lines[i], s2Lines[i]) == false)
                {
                    message = "SAI KẾT QUẢ 1";
                    return false;
                }
                i++;
            }
            while (i < s1Lines.Length)
            {
                if (!IsEmptyLine(s1Lines[i]))
                {
                    message = "SAI KẾT QUẢ 2";
                    return false;
                }

            }
            while (i < s2Lines.Length)
            {
                if (!IsEmptyLine(s2Lines[i]))
                {
                    message = "SAI KẾT QUẢ 3";
                    return false;
                }
            }
            message = "ĐÚNG KẾT QUẢ";
            return true;
        }

 /// <summary>
 /// Removes automation from a test case.
 /// </summary>
 public void RemoveAutomation(ITestCase testCase)
 {
     testCase.WorkItem.Open();
     testCase.Implementation = null;
     testCase.CustomFields["Automation status"].Value = "Not Automated";
     testCase.Save();
 }

 public TestCaseWorker(ITestCase testCase, int index)
 {
     if (testCase == null)
         throw new ArgumentNullException("testCase");
     this.testCase = testCase;
     this.index = index;
 }

        private static string GetShortName(ITestCase tc)
        {
            var shortName = new StringBuilder();

            var classFullName = tc.TestMethod.TestClass.Class.Name;
            var dotIndex = classFullName.LastIndexOf('.');
            if (dotIndex >= 0)
                shortName.Append(classFullName.Substring(dotIndex + 1));
            else
                shortName.Append(classFullName);

            shortName.Append(".");
            shortName.Append(tc.TestMethod.Method.Name);

            // We need to shorten the arguments list if it's long. Let's arbitrarily pick 50 characters.
            var argumentsIndex = tc.DisplayName.IndexOf('(');
            if (argumentsIndex >= 0 && tc.DisplayName.Length - argumentsIndex > 50)
            {
                shortName.Append(tc.DisplayName.Substring(argumentsIndex, 46));
                shortName.Append("...");
                shortName.Append(")");
            }
            else if (argumentsIndex >= 0)
                shortName.Append(tc.DisplayName.Substring(argumentsIndex));

            return shortName.ToString();
        }

 #region Add/Remove Test cases
 /// <summary>
 /// Adds the test case to the suite
 /// </summary>
 /// <param name="testCase"><see cref="TestCase"/> instance to add.</param>
 /// <exception cref="InvalidOperationException">
 /// The suite already contains a test case with the same name as <paramref name="testCase"/>.
 /// </exception>
 public void Add(ITestCase testCase)
 {
     if (testCase == null)
         throw new ArgumentNullException("testCase");
     if (this.testCases.Contains(testCase.Name))
         throw new InvalidOperationException("TestCase " + testCase.Name + " already in collection");
     this.testCases.Add(testCase);

 /// <summary>
 /// Initializes a new instance of the <see cref="TestCleanupFailure"/> class.
 /// </summary>
 public TestCleanupFailure(ITestCase testCase, string displayName, string[] exceptionTypes, string[] messages, string[] stackTraces, int[] exceptionParentIndices)
     : base(testCase, displayName)
 {
     StackTraces = stackTraces;
     Messages = messages;
     ExceptionTypes = exceptionTypes;
     ExceptionParentIndices = exceptionParentIndices;
 }

 public bool Filter(IFixture fixture, ITestCase testCase)
 {
     XmlTestCase xtestCase = this.Searcher.GetTestCase(fixture.Name, testCase.Name);
     if (xtestCase == null)
         return false;
     else
         return xtestCase.State == TestState.Failure;
 }

        bool FilterIncludedNames(ITestCase testCase)
        {
            // No names in the filter == everything is okay
            if (IncludedNames.Count == 0)
                return true;

            return IncludedNames.Contains(testCase.DisplayName);
        }

 public TestCaseFinished(ITestCase testCase, decimal executionTime, int testsRun, int testsFailed, int testsSkipped)
     : base(testCase)
 {
     ExecutionTime = executionTime;
     TestsRun = testsRun;
     TestsFailed = testsFailed;
     TestsSkipped = testsSkipped;
 }

 public static ExpectedExceptionTestCase ExpectedException(ITestCase testCase, Type exceptionType)
 {
     if (testCase == null)
         throw new ArgumentNullException("testCase");
     if (exceptionType == null)
         throw new ArgumentNullException("exceptionType");
     return new ExpectedExceptionTestCase(testCase, exceptionType);
 }

 public static ITestCase DecorateTest(ITestCase testCase, MethodInfo method)
 {
     ITestCase test = testCase;
     foreach (TestDecoratorAttributeBase attribute in method.GetCustomAttributes(typeof(TestDecoratorAttributeBase), true))
     {
         test = attribute.Decorate(test);
     }
     return test;
 }

        /// <summary>
        /// Filters the given method using the defined filter values.
        /// </summary>
        /// <param name="testCase">The test case to filter.</param>
        /// <returns>Returns <c>true</c> if the test case passed the filter; returns <c>false</c> otherwise.</returns>
        public bool Filter(ITestCase testCase)
        {
            if (!FilterIncludedTraits(testCase))
                return false;
            if (!FilterExcludedTraits(testCase))
                return false;

            return true;
        }

        int Compare(ITestCase x, ITestCase y)
        {
            var xHash = x.UniqueID.GetHashCode();
            var yHash = y.UniqueID.GetHashCode();

            if (xHash == yHash)
                return 0;
            if (xHash < yHash)
                return -1;
            return 1;
        }