Added more f# tests

TUnit.TestProject.FSharp/AfterTestAttributeTests.fs

@@ -0,0 +1,31 @@
+namespace TUnit.TestProject.FSharp
+
+open System
+open System.IO
+open System.Threading.Tasks
+open TUnit.Assertions
+open TUnit.Assertions.Extensions
+open TUnit.Core.Interfaces
+open TUnit.Core
+open TUnit.Assertions.FSharp.Operations
+
+
+//type WriteFileAfterTestAttribute() =
+//        inherit System.Attribute()
+//        interface ITestEndEventReceiver with
+//            member _.OnTestEnd(testContext: AfterTestContext) =
+//                task {
+//                    Console.WriteLine("Writing file inside WriteFileAfterTestAttribute!")
+//                    do! FilePolyfill.WriteAllTextAsync(filename, "Foo!")
+//                } :> Task
+//            member _.Order = 0
+
+//type AfterTestAttributeTests() =
+//    static let filename = sprintf "%s-AfterTestAttributeTests.txt" (Guid.NewGuid().ToString("N"))
+
+//    [<Test>]
+//    [<WriteFileAfterTest>]
+//    member _.Test() =
+//        async{
+//             do! check(Assert.That<bool>(File.Exists(filename)).IsFalse())
+//        }

TUnit.TestProject.FSharp/ArgumentWithImplicitConverterTests.fs

@@ -0,0 +1,33 @@
+namespace TUnit.TestProject.FSharp
+
+open System
+open TUnit.Core
+
+// F# equivalents for ArgumentWithImplicitConverterTests.cs
+
+type ExplicitInteger =
+    | ExplicitInteger of int
+    static member op_Explicit(i: int) = ExplicitInteger i
+    override this.ToString() =
+        let (ExplicitInteger i) = this in i.ToString()
+
+type ImplicitInteger =
+    | ImplicitInteger of int
+    static member op_Implicit(i: int) = ImplicitInteger i
+    override this.ToString() =
+        let (ImplicitInteger i) = this in i.ToString()
+
+type ArgumentWithImplicitConverterTests() =
+    [<Test>]
+    [<Arguments(1)>]
+    [<Arguments(2)>]
+    [<Arguments(3)>]
+    member _.Explicit(integer: ExplicitInteger) =
+        Console.WriteLine(integer)
+
+    [<Test>]
+    [<Arguments(1)>]
+    [<Arguments(2)>]
+    [<Arguments(3)>]
+    member _.Implicit(integer: ImplicitInteger) =
+        Console.WriteLine(integer)

TUnit.TestProject.FSharp/AssemblyHooks.fs

@@ -0,0 +1,62 @@
+namespace TUnit.TestProject.FSharp
+
+open System.Threading
+open System.Threading.Tasks
+open TUnit.Assertions
+open TUnit.Assertions.Extensions
+open TUnit.Core
+open TUnit.Assertions.FSharp.Operations
+
+// F# equivalent of AssemblyHooks.cs
+
+type AssemblyHooks() =
+    static let mutable beforeHook1Calls = 0
+
+    [<Before(HookType.Assembly)>]
+    static member BeforeHook1() =
+        beforeHook1Calls <- beforeHook1Calls + 1
+
+#if NET
+    [<Before(HookType.Assembly)>]
+    static member BeforeHook2(context: AssemblyHookContext) = async{
+        do! check(Assert.That(context.TestCount).IsPositive())
+    }
+#endif
+
+    [<Before(HookType.Assembly)>]
+    [<Timeout(30000)>]
+    static member BeforeHook3(cancellationToken: CancellationToken) =
+        ()
+
+#if NET
+    [<Before(HookType.Assembly)>]
+    [<Timeout(30000)>]
+    static member BeforeHook4(context: AssemblyHookContext, cancellationToken: CancellationToken) = async {
+        do! check(Assert.That(context.TestCount).IsPositive())
+    }
+#endif
+
+    [<After(HookType.Assembly)>]
+    static member AfterHook1() = async {
+        do! check(Assert.That(beforeHook1Calls).IsEqualTo(1))
+    }
+
+#if NET
+    [<After(HookType.Assembly)>]
+    static member AfterHook2(context: AssemblyHookContext) = async {
+        do! check(Assert.That(context.TestCount).IsPositive())
+    }
+#endif
+
+    [<After(HookType.Assembly)>]
+    [<Timeout(30000)>]
+    static member AfterHook3(cancellationToken: CancellationToken) =
+        ()
+
+#if NET
+    [<After(HookType.Assembly)>]
+    [<Timeout(30000)>]
+    static member AfterHook4(context: AssemblyHookContext, cancellationToken: CancellationToken)  = async {
+        do! check(Assert.That(context.TestCount).IsPositive())
+    }
+#endif

TUnit.TestProject.FSharp/BasicTests.fs

@@ -0,0 +1,19 @@
+namespace TUnit.TestProject.FSharp
+
+open System.Threading.Tasks
+open TUnit.Core
+
+// Equivalent of BasicTests.cs
+
+type BasicTests() =
+    [<Test>]
+    member _.SynchronousTest() =
+        () // Dummy method
+
+    [<Test>]
+    member _.AsynchronousTest() : Task =
+        Task.CompletedTask
+
+    [<Test>]
+    member _.ValueTaskAsynchronousTest() : ValueTask =
+        ValueTask()

TUnit.TestProject.FSharp/ByteArgumentTests.fs

@@ -0,0 +1,17 @@
+namespace TUnit.TestProject.FSharp
+
+open TUnit.Core
+
+// F# equivalent of ByteArgumentTests.cs
+
+type ByteArgumentTests() =
+    [<Test>]
+    [<Arguments(1uy)>]
+    member _.Normal(b: byte) =
+        () // Dummy method
+
+    [<Test>]
+    [<Arguments(1uy)>]
+    [<Arguments(null)>]
+    member _.Nullable(b: byte option) =
+        () // Dummy method

TUnit.TestProject.FSharp/ClassConstructorTest.fs

@@ -1,12 +1,10 @@
-namespace TUnit.TestProject
+namespace TUnit.TestProject.FSharp
 
 open TUnit.Core
 
 [<ClassConstructor(typeof<DependencyInjectionClassConstructor>)>]
 type ClassConstructorTest(dummyReferenceTypeClass: DummyReferenceTypeClass) =
-
     member _.DummyReferenceTypeClass = dummyReferenceTypeClass
-
     [<Test>]
     member _.Test() = ()
 

TUnit.TestProject.FSharp/ClassDataSourceDrivenTests.fs

@@ -1,4 +1,4 @@
-namespace TUnit.TestProject
+namespace TUnit.TestProject.FSharp
 
 open System.Threading.Tasks
 open TUnit.Assertions

TUnit.TestProject.FSharp/ConflictingDependsOnTests.fs

@@ -0,0 +1,16 @@
+namespace TUnit.TestProject.FSharp
+
+open System
+open System.Threading.Tasks
+open System.Diagnostics.CodeAnalysis
+open TUnit.Core
+
+[<SuppressMessage("Usage", "TUnit0033:Conflicting DependsOn attributes")>]
+type ConflictingDependsOnTests() =
+    [<Test>]
+    [<DependsOn("Test2")>]
+    member _.Test1() : Task = Task.Delay(TimeSpan.FromSeconds(5.0))
+
+    [<Test>]
+    [<DependsOn("Test1")>]
+    member _.Test2() : Task = Task.CompletedTask

TUnit.TestProject.FSharp/ConflictingDependsOnTests3.fs

@@ -0,0 +1,28 @@
+namespace TUnit.TestProject.FSharp
+
+open System
+open System.Threading.Tasks
+open TUnit.Core
+open System.Diagnostics.CodeAnalysis
+
+[<SuppressMessage("Usage", "TUnit0033:Conflicting DependsOn attributes")>]
+type ConflictingDependsOnTests3() =
+    [<Test>]
+    [<DependsOn("Test5")>]
+    member _.Test1() : Task = Task.Delay(TimeSpan.FromSeconds(5.0))
+
+    [<Test>]
+    [<DependsOn("Test1")>]
+    member _.Test2() : Task = Task.CompletedTask
+
+    [<Test>]
+    [<DependsOn("Test2")>]
+    member _.Test3() : Task = Task.CompletedTask
+
+    [<Test>]
+    [<DependsOn("Test3")>]
+    member _.Test4() : Task = Task.CompletedTask
+
+    [<Test>]
+    [<DependsOn("Test4")>]
+    member _.Test5() : Task = Task.CompletedTask

TUnit.TestProject.FSharp/ConsoleConcurrentTests.fs

@@ -0,0 +1,43 @@
+namespace TUnit.TestProject.FSharp
+
+open System
+open TUnit.Core
+
+// F# equivalent of ConsoleConcurrentTests.cs
+
+type ConsoleConcurrentTests() =
+    [<Test>]
+    [<Repeat(25)>]
+    member _.Test1() = Console.WriteLine("Test1")
+    [<Test>]
+    [<Repeat(25)>]
+    member _.Test2() = Console.WriteLine("Test2")
+    [<Test>]
+    [<Repeat(25)>]
+    member _.Test3() = Console.WriteLine("Test3")
+    [<Test>]
+    [<Repeat(25)>]
+    member _.Test4() = Console.WriteLine("Test4")
+    [<Test>]
+    [<Repeat(25)>]
+    member _.Test5() = Console.WriteLine("Test5")
+    [<Test>]
+    [<Repeat(25)>]
+    member _.Test6() = Console.WriteLine("Test6")
+    [<Test>]
+    [<Repeat(25)>]
+    member _.Test7() =
+        Console.WriteLine("Test7")
+        Console.WriteLine("Test7")
+        Console.WriteLine("Test7")
+        Console.WriteLine("Test7")
+        Console.WriteLine("Test7")
+    [<Test>]
+    [<Repeat(25)>]
+    member _.Test8() = Console.WriteLine("Test8")
+    [<Test>]
+    [<Repeat(25)>]
+    member _.Test9() = Console.WriteLine("Test9")
+    [<Test>]
+    [<Repeat(25)>]
+    member _.Test10() = Console.WriteLine("Test10")

TUnit.TestProject.FSharp/CustomSkipAttribute.fs

@@ -0,0 +1,6 @@
+namespace TUnit.TestProject.FSharp
+
+open TUnit.Core
+
+type CustomSkipAttribute() =
+    inherit SkipAttribute("Some Reason")

TUnit.TestProject.FSharp/DataDrivenTests.fs

@@ -0,0 +1,64 @@
+namespace TUnit.TestProject.FSharp
+
+open System
+open TUnit.Core
+
+// F# equivalent of DataDrivenTests.cs
+
+type TestEnum =
+    | One = 0
+    | Two = 1
+
+type DataDrivenTests() =
+    [<Test>]
+    [<Arguments(1)>]
+    [<Arguments(2)>]
+    [<Arguments(3)>]
+    member _.DataSource_Method(value: int) =
+        ()
+
+    [<Test>]
+    [<Arguments(1, "String")>]
+    [<Arguments(2, "String2")>]
+    [<Arguments(3, "String3")>]
+    member _.DataSource_Method2(value: int, value2: string) =
+        ()
+
+    [<Test>]
+    [<Arguments(TestEnum.One)>]
+    [<Arguments(TestEnum.Two)>]
+    [<Arguments(-1)>]
+    member _.EnumValue(testEnum: TestEnum) =
+        ()
+
+    [<Test>]
+    [<Arguments(null)>]
+    member _.NullValue(value: string option) =
+        ()
+
+    [<Test>]
+    [<Arguments("")>]
+    member _.EmptyString(value: string) =
+        ()
+
+    [<Test>]
+    [<Arguments("Foo bar!")>]
+    member _.NonEmptyString(value: string) =
+        ()
+
+    [<Test>]
+    [<Arguments(null)>]
+    [<Arguments(false)>]
+    [<Arguments(true)>]
+    member _.BooleanString(value: bool option) =
+        ()
+
+    [<Test>]
+    [<Arguments(typeof<obj>)>]
+    member _.Type(value: Type) =
+        ()
+
+    [<Test>]
+    [<Arguments(Int32.MaxValue)>]
+    member _.IntMaxValue(value: int) =
+        ()

TUnit.TestProject.FSharp/DataSourceClassCombinedWithDataSourceMethod.fs

@@ -0,0 +1,10 @@
+namespace TUnit.TestProject.FSharp
+
+open System.Threading.Tasks
+open TUnit.Core
+
+// Equivalent of DataSourceClassCombinedWithDataSourceMethod.cs
+
+type DataSourceClassCombinedWithDataSourceMethod() =
+    [<Test>]
+    member _.Test(x: int) = ()

TUnit.TestProject.FSharp/DataSourceGeneratorTests.fs

@@ -0,0 +1,10 @@
+namespace TUnit.TestProject.FSharp
+
+open System.Threading.Tasks
+open TUnit.Core
+
+// Equivalent of DataSourceGeneratorTests.cs
+
+type DataSourceGeneratorTests() =
+    [<Test>]
+    member _.Test(x: int) = ()