Bugfix: don't try to instantiate abstract classes with tests.

Author: mausch

Fuchu.Tests/MbUnitTestTypes.fs

@@ -86,4 +86,9 @@ module MbUnitTestTypes =
             [
                 TestCase("test 1", fun () -> ())
                 TestCase("test 2", fun () -> ())
-            ]
+            ]
+
+    [<AbstractClass>]
+    type AbstractWithTest() =
+        [<Test>]
+        member x.ATest() = ()

Fuchu.Tests/MbUnitTests.fs

@@ -83,6 +83,13 @@ module MbUnitTests =
                                                     TestLabel("DivTest(1000,10,100)", TestCase _), 
                                                     TestLabel("DivTest(4195835,3145729,1.3338196)", TestCase _)))))))) -> ()
                 | _ -> failtestf "unexpected %A" test
+
+            testCase "abstract class" <| fun _ ->
+                let testType = typeof<AbstractWithTest>
+                let test = MbUnitTestToFuchu testType
+                match test with
+                | TestList (Seq.One (TestList Seq.Empty)) -> ()
+                | _ -> failtestf "unexpected %A" test
         ]
 
     type MbUnitTestsFromFuchu() =

Fuchu/xUnitHelpers.fs

@@ -59,39 +59,42 @@ module XunitHelpers =
                                Invoke = fun (o: obj) -> invoke o m })
 
     let TestToFuchu (attr: TestAttributes) (testCategory: Type -> string) (testType: Type) (testMethods: TestMethod seq) =
-        let methods = nonIgnoredMethods attr.Ignore testType
-        let methodsWithAttrs = methodsWithAttrs methods
-        let setupMethods = methodsWithAttrs [attr.Setup]
-        let teardownMethods = methodsWithAttrs [attr.TearDown]
-        let fixtureSetupMethods = methodsWithAttrs [attr.FixtureSetup]
+        if testType.IsAbstract
+            then TestList []
+            else
+                let methods = nonIgnoredMethods attr.Ignore testType
+                let methodsWithAttrs = methodsWithAttrs methods
+                let setupMethods = methodsWithAttrs [attr.Setup]
+                let teardownMethods = methodsWithAttrs [attr.TearDown]
+                let fixtureSetupMethods = methodsWithAttrs [attr.FixtureSetup]
 
-        TestList <| seq {
-            if Seq.length testMethods > 0 then
-                yield testList (testType.FullName + testCategory testType) <| seq {
-                    let testInstance = create testType
-                    let inline invoke metod = invoke testInstance metod
-                    Seq.iter invoke fixtureSetupMethods
-                    for tm in testMethods ->
-                        test tm.Name {
-                            try
-                                Seq.iter invoke setupMethods
-                                try
-                                    tm.Invoke testInstance
-                                    match tm.ExpectedException with
-                                    | Some expectedExc ->
-                                        failtestf "Expected exception '%s' but no exception was thrown" expectedExc
-                                    | None -> ()
-                                with
-                                | :? TargetInvocationException as e -> 
-                                    match tm.ExpectedException with
-                                    | Some expectedExc ->
-                                        let innerExc = e.InnerException.GetType().AssemblyQualifiedName
-                                        if expectedExc <> innerExc
-                                            then failtestf "Expected exception '%s', got '%s'" expectedExc innerExc
-                                    | None ->
-                                        raise e.InnerException
-                            finally
-                                Seq.iter invoke teardownMethods
+                TestList <| seq {
+                    if Seq.length testMethods > 0 then
+                        yield testList (testType.FullName + testCategory testType) <| seq {
+                            let testInstance = create testType
+                            let inline invoke metod = invoke testInstance metod
+                            Seq.iter invoke fixtureSetupMethods
+                            for tm in testMethods ->
+                                test tm.Name {
+                                    try
+                                        Seq.iter invoke setupMethods
+                                        try
+                                            tm.Invoke testInstance
+                                            match tm.ExpectedException with
+                                            | Some expectedExc ->
+                                                failtestf "Expected exception '%s' but no exception was thrown" expectedExc
+                                            | None -> ()
+                                        with
+                                        | :? TargetInvocationException as e -> 
+                                            match tm.ExpectedException with
+                                            | Some expectedExc ->
+                                                let innerExc = e.InnerException.GetType().AssemblyQualifiedName
+                                                if expectedExc <> innerExc
+                                                    then failtestf "Expected exception '%s', got '%s'" expectedExc innerExc
+                                            | None ->
+                                                raise e.InnerException
+                                    finally
+                                        Seq.iter invoke teardownMethods
+                                }
                         }
-                }
         }