Esempio n. 1
0
        public void AddingMethodReport()
        {
            Type type = typeof(TestClass);
            MethodInfo succeededMethod = type.GetMethod("TestName");
            MethodInfo failedMethod = type.GetMethod("SecondTest");
            ClassReport report = new SimpleClassReport(type);

            MethodReport methodReport1 = new MethodReport(succeededMethod);
            report.Add(methodReport1);
            AssertEx.That(report.Status is ReportStatus.Success, Is.True());
            AssertEx.That(report.SucceededTests, Is.EqualTo(1));
            AssertEx.That(report.RunnedTests, Is.EqualTo(1));

            MethodReport methodReport2 = new MethodReport(failedMethod, new AssertException("Exception Text"));
            report.Add(methodReport2);
            AssertEx.That(report.Status is ReportStatus.Failed, Is.True());
            AssertEx.That(report.FailedTests, Is.EqualTo(1));
            AssertEx.That(report.RunnedTests, Is.EqualTo(2));

            //This tests, that new reports of the same method will be replaced
            MethodReport methodReport3 = new MethodReport(succeededMethod, new NullReferenceException());
            report.Add(methodReport3);
            AssertEx.That(report.Status is ReportStatus.Error, Is.True());
            AssertEx.That(report.FailedTests, Is.EqualTo(2));
            AssertEx.That(report.RunnedTests, Is.EqualTo(2));

            //Reports for methods of another class aren't allowed
            MethodInfo methodInfo = typeof(AnotherTestClass).GetMethod("AnotherTest");
            MethodReport reportOfMethodNotInClass = new MethodReport(methodInfo);
            AssertEx.That(() => report.Add(reportOfMethodNotInClass), Throws.An<ArgumentException>());
        }
Esempio n. 2
0
 private static string CreateReportText(MethodReport report)
 {
     StringBuilder builder = new StringBuilder(report.Text);
     builder.Append("\n\n");
     builder.Append(report.RaisedException.StackTrace);
     return builder.ToString();
 }
Esempio n. 3
0
        public void EqualsAndHashCode()
        {
            Report report = new MethodReport(typeof(TestClass).GetMethod("TestName"), new AssertException("Exception test."));

            //Using IsTrue/IsFalse to cover all paths (aren't covered, when using Equals)
            //Equal tests
            Assert.IsTrue(report.Equals(report), "An object should allways be equal to itself (reference).");
            AssertEx.That(report.GetHashCode(), Is.EqualTo(report.GetHashCode()), "Equal objects should have equal hashcodes.");

            Report equal = new MethodReport(typeof(TestClass).GetMethod("TestName"), new AssertException("Exception test."));
            Assert.IsTrue(report.Equals(equal), "An object should be equal to an object with the same attributes.");
            AssertEx.That(report.GetHashCode(), Is.EqualTo(equal.GetHashCode()), "Equal objects should have equal hashcodes.");

            //Not equal tests
            Assert.IsFalse(report.Equals(null), "An object shouldn't be equal to null.");

            object unequal = new object();
            Assert.IsFalse(report.Equals(unequal), "An object shouldn't be equal to an object of an other type.");
            AssertEx.That(report.GetHashCode(), Is.Not(unequal.GetHashCode()), "Unequal objects shouldn't have equal hashcodes.");

            unequal = new MethodReport(typeof(TestClass).GetMethod("UnequalMethod"), new AssertException("Exception test."));
            Assert.IsFalse(report.Equals(unequal), "An object shouldn't be equal to an object of an other type.");
            AssertEx.That(report.GetHashCode(), Is.Not(unequal.GetHashCode()), "Unequal objects shouldn't have equal hashcodes.");

            unequal = new MethodReport(typeof(TestClass).GetMethod("TestName"), new NullReferenceException("Exception test."));
            Assert.IsFalse(report.Equals(unequal), "An object shouldn't be equal to an object with different attributes.");
            AssertEx.That(report.GetHashCode(), Is.Not(unequal.GetHashCode()), "Unequal objects shouldn't have equal hashcodes.");
        }
Esempio n. 4
0
        public void RunSpecificTestOfJUUTTestClass()
        {
            TestClassSession session = new TestClassSession(typeof(TestClassMock));
            session.Add(typeof(TestClassMock).GetMethod("Foo"));

            TestRunner runner = new SimpleTestRunner();
            ClassReport classReport = runner.Run(session);
            AssertThatTheMethodsAreCalledInTheCorrectOrderAfterRunningASpecificTest();

            //Checking the returned test report
            Report report = GetFirstMethodReportFrom(classReport.MethodReports);
            Report expectedReport = new MethodReport(typeof(TestClassMock).GetMethod("Foo"));
            AssertEx.That(report, Is.EqualTo(expectedReport));
        }
Esempio n. 5
0
        public void MessageCreation()
        {
            MethodInfo testMethod = typeof(TestClass).GetMethod("TestName");
            Exception raisedException = new AssertException("Exception Text");

            Report report = new MethodReport(testMethod, raisedException);
            AssertEx.That(report.Text, Is.EqualTo("The TestName-Method failed: " + raisedException.Message));

            raisedException = new NullReferenceException("Null reference");
            report = new MethodReport(testMethod, raisedException);
            AssertEx.That(report.Text, Is.EqualTo("The TestName-Method threw an unexpected exception: " + raisedException.Message));

            report = new MethodReport(testMethod);
            AssertEx.That(report.Text, Is.EqualTo("The TestName-Method passed successfully."));
        }
Esempio n. 6
0
        public void Creation()
        {
            MethodInfo testMethod = typeof(TestClass).GetMethod("TestName");
            Exception raisedException = new AssertException("Exception Text");

            Report report = new MethodReport(testMethod, raisedException);
            AssertEx.That(report.TestClass, Is.EqualTo(typeof(TestClass)));
            AssertEx.That(report.Status is ReportStatus.Failed, Is.True());

            //Check that a report can be created with other JUUTMethodAttributes
            report = new MethodReport(typeof(TestClass).GetMethod("SetUp"), raisedException);

            //This allows to create a test method report without a raised exception
            report = new MethodReport(testMethod);
            AssertEx.That(report.TestClass, Is.EqualTo(typeof(TestClass)));
            AssertEx.That(report.Status is ReportStatus.Success, Is.True());

            testMethod = new DynamicMethod("Foo", null, null);
            AssertEx.That(() => { new MethodReport(testMethod, raisedException); }, Throws.An<ArgumentException>());
            AssertEx.That(() => { new MethodReport(testMethod); }, Throws.An<ArgumentException>());

            AssertEx.That(() => { new MethodReport(null, raisedException); }, Throws.An<ArgumentException>());
            AssertEx.That(() => { new MethodReport(null); }, Throws.An<ArgumentException>());
        }
Esempio n. 7
0
        public void Add(MethodReport report)
        {
            if (report.TestClass != TestClass) {
                throw new ArgumentException("The declaring type of the given report isn't equal to the declaring type of this class report.");
            }

            Status = report.Status.IsWorseThan(Status) ? report.Status : Status;
            AdjustCounters(report);
            Reports[report.Method] = report;
        }
Esempio n. 8
0
 private void AdjustCounters(MethodReport newReport)
 {
     if (Reports.ContainsKey(newReport.Method)) {
         Reports[newReport.Method].Status.DecrementCounterFor(this);
     }
     newReport.Status.IncrementCounterFor(this);
 }
Esempio n. 9
0
        public void RunTestsOfJUUTTestClassWithFailingClassSetUp()
        {
            TestClassSession session = new TestClassSession(typeof(TestClassMockWithFailingClassSetUp));
            session.Add(typeof(TestClassMockWithFailingClassSetUp).GetMethod("Bar"));

            //Testing the run of a specific testMethod
            TestRunner runner = new SimpleTestRunner();
            ClassReport classReport = runner.Run(session);
            AssertThatTheMethodsAreCalledInTheCorrectOrderAfterRunningATestWithFailingClassSetUp();

            //Checking the returned test report
            Report report = GetFirstMethodReportFrom(classReport.MethodReports);
            Exception raisedException = new NullReferenceException("Failing class set up.");
            Report expectedReport = new MethodReport(typeof(TestClassMockWithFailingClassSetUp).GetMethod("ClassSetUp"), raisedException);
            AssertEx.That(report, Is.EqualTo(expectedReport));

            //Testing the run of all tests
            MethodCallOrder = new List<string>();
            session.AddAll();
            classReport = runner.Run(session);
            AssertThatTheMethodsAreCalledInTheCorrectOrderAfterRunningATestWithFailingClassSetUp();

            //Checking the returned test reports
            ICollection<MethodReport> reports = classReport.MethodReports;
            raisedException = new NullReferenceException("Failing class set up.");
            expectedReport = new MethodReport(typeof(TestClassMockWithFailingClassSetUp).GetMethod("ClassSetUp"), raisedException);
            AssertEx.That(reports.Count, Is.EqualTo(1));
            AssertEx.That(GetFirstMethodReportFrom(reports), Is.EqualTo(expectedReport));
        }
Esempio n. 10
0
        private void AssertThatTheReportIsEqualToFooOrBar(Report report)
        {
            Report fooReport = new MethodReport(typeof(TestClassMock).GetMethod("Foo"));
            Report barReport = new MethodReport(typeof(TestClassMock).GetMethod("Bar"));

            AssertEx.That(report, Matches.AnyOf(Is.EqualTo(fooReport), Is.EqualTo(barReport)));
        }
Esempio n. 11
0
        public void TextCreation()
        {
            Type type = typeof(TestClass);
            MethodInfo succeededMethod = type.GetMethod("TestName");
            MethodInfo failedMethod = type.GetMethod("SecondTest");
            ClassReport report = new SimpleClassReport(type);

            AssertEx.That(report.Text, Is.EqualTo("No tests have been runned."));

            MethodReport methodReport1 = new MethodReport(succeededMethod);
            report.Add(methodReport1);
            AssertEx.That(report.Text, Is.EqualTo("1 test runned: 0 failed, 1 succeeded"));

            MethodReport methodReport2 = new MethodReport(failedMethod, new AssertException("Exception Text"));
            report.Add(methodReport2);
            AssertEx.That(report.Text, Is.EqualTo("2 tests runned: 1 failed, 1 succeeded\n" +
                                                  "\n" +
                                                  "The SecondTest-Method failed."));

            MethodReport methodReport3 = new MethodReport(succeededMethod, new NullReferenceException());
            report.Add(methodReport3);
            AssertEx.That(report.Text, Is.EqualTo("2 tests runned: 2 failed, 0 succeeded\n" +
                                                  "\n" +
                                                  "The TestName-Method threw an unexpected exception.\n" +
                                                  "\n" +
                                                  "The SecondTest-Method failed."));
        }
Esempio n. 12
0
 public void ReportToString()
 {
     Exception raisedException = new NullReferenceException("Exception text");
     Report report = new MethodReport(typeof(TestClass).GetMethod("TestName"), raisedException);
     AssertEx.That(report.ToString(), Is.EqualTo(report.Text));
 }
Esempio n. 13
0
 ////////////////////////////////////////////////////////
 // Generated GetHashCode and Equals                   //
 ////////////////////////////////////////////////////////
 private bool Equals(MethodReport other)
 {
     return Status.Equals(other.Status) && Method.Equals(other.Method);
 }