C# Core.TestName类代码示例

 /// <summary>
 /// Called when a test case is starting
 /// </summary>
 /// <param name="testName">The name of the test case</param>
 public void TestStarted(TestName testName)
 {
     if (this.eventListener != null)
     {
         this.eventListener.TestStarted(testName);
     }
 }

 public void SetUp()
 {
     testCommand = MockRepository.GenerateStub<ITestCommand>();
     testName = new TestName { TestID = new TestID(), FullName = "fullName" };
     var testCommandsByTestName = new Dictionary<TestName, ITestCommand> { { testName, testCommand } };
     testFilter = new NUnitTestFilter(testCommandsByTestName);
     test = MockRepository.GenerateStub<ITest>();
 }

 public AggregatingTestRunner(int runnerID)
 {
     this.runnerID = runnerID;
     this.testName = new TestName();
     testName.TestID = new TestID(AggregateTestID);
     testName.RunnerID = this.runnerID;
     testName.FullName = testName.Name = "Not Loaded";
 }

		/// <summary>
		/// Constructs a test given its name
		/// </summary>
		/// <param name="name">The name of the test</param>
		protected Test( string name )
		{
			this.testName = new TestName();
			this.testName.FullName = name;
			this.testName.Name = name;
			this.testName.TestID = new TestID();

            this.runState = RunState.Runnable;
		}

        /// <summary>
        /// Constructs a test given the path through the
        /// test hierarchy to its parent and a name.
        /// </summary>
        /// <param name="pathName">The parent tests full name</param>
        /// <param name="name">The name of the test</param>
        protected Test( string pathName, string name )
        {
            this.testName = new TestName();
            this.testName.FullName = pathName == null || pathName == string.Empty
                ? name : pathName + "." + name;
            this.testName.Name = name;
            this.testName.TestID = new TestID();

            this.runState = RunState.Runnable;
        }

        private TestResult BuildError(Exception e, TestConsoleAccess consoleAccess)
        {
            TestName testName = new TestName();
            testName.Name = mPNUnitTestInfo.TestName;
            testName.FullName = mPNUnitTestInfo.TestName;
            testName.TestID = new TestID();

            TestResult result = new PNUnitTestResult(testName, consoleAccess.GetTestOutput());
            result.Error(e);
            return result;
        }

        public void TestStarted(TestName testName)
        {
            TestCase ourCase = testConverter.GetCachedTestCase(testName.UniqueName);

            // Simply ignore any TestName not found in the cache
            if (ourCase != null)
            {
                this.testLog.RecordStart(ourCase);
                // Output = testName.FullName + "\r";
            }

        }

		/// <summary>
		/// Construct from an ITest
		/// </summary>
		/// <param name="test">Test from which a TestNode is to be constructed</param>
		public TestInfo( ITest test )
		{
			this.testName = (TestName)test.TestName.Clone();
			this.testType = test.TestType;

            this.runState = test.RunState;
			this.ignoreReason = test.IgnoreReason;
			this.description = test.Description;
			this.isSuite = test.IsSuite;

			if (test.Categories != null) 
				this.categories.AddRange(test.Categories);
			if (test.Properties != null)
			{
				this.properties = new ListDictionary();
				foreach( DictionaryEntry entry in test.Properties )
					this.properties.Add( entry.Key, entry.Value );
			}

			this.testCaseCount = test.TestCount;
		}

        public static ITest MockTest(string name, ITest parentFixture)
        {
            var m = new Mock<ITest>();

            var tn = new TestName
                {
                    FullName = name,
                    Name = name
                };
            var ptn = new TestName
                {
                    FullName = parentFixture.TestName.FullName,
                    Name = parentFixture.TestName.Name,
                };


            m.Setup(_ => _.TestName).Returns(tn);
            m.Setup(_ => _.Parent.TestName).Returns(ptn);
            m.Setup(_ => _.TestType).Returns("Test");
            return m.Object;
        }

        public static ITest MockTestFixture(string name, string namespaceName)
        {
            var m = new Mock<ITest>();

            var tn = new TestName
                {
                    FullName = name,
                    Name = name
                };
            var ptn = new TestName
                {
                    FullName = namespaceName,
                    Name = namespaceName
                };


            m.Setup(_ => _.TestName).Returns(tn);
            m.Setup(_ => _.Parent.TestName).Returns(ptn);
            m.Setup(_ => _.Tests).Returns(new ArrayList());
            m.Setup(_ => _.TestType).Returns("TestFixture");
            return m.Object;
        }

 public void TestStarted(TestName testName)
 {
     log(" • {0}".Fmt(testName.Name));
 }

 /// <summary>
 /// Construct a TestResult given a TestName
 /// </summary>
 /// <param name="testName">A TestName</param>
 public TestResult(TestName testName)
     : this(new TestInfo( testName ))
 {
 }

 public void TestStarted(TestName testName)
 {
     mPerfCollector.Collect(false, testName.FullName);
 }

 void EventListener.TestStarted(TestName testName)
 {
     this.FireTestStarting( testName );
 }

 public void SuiteStarted(TestName testName)
 {
 }