Adding F# and VB.NET Basic templates

TUnit.Templates.Tests/AspNetTemplateTests.cs

@@ -2,7 +2,7 @@
 
 public class AspNetTemplateTests : TemplateTestBase
 {
-    protected override string TemplateShortName => "TUnit.AspNet";
+    protected override string TemplateShortName { get; set; } = "TUnit.AspNet";
 
     [Test]
     public async Task InstantiationTest()

TUnit.Templates.Tests/AspireStarterTemplateTests.cs

@@ -2,7 +2,7 @@
 {
     public class AspireStarterTemplateTests : TemplateTestBase
     {
-        protected override string TemplateShortName => "TUnit.Aspire.Starter";
+        protected override string TemplateShortName { get; set; } = "TUnit.Aspire.Starter";
 
         [Test]
         public async Task InstantiationTest()

TUnit.Templates.Tests/AspireTemplateTests.cs

@@ -2,7 +2,7 @@
 {
     public class AspireTemplateTests:TemplateTestBase
     {
-        protected override string TemplateShortName => "TUnit.Aspire.Test";
+        protected override string TemplateShortName { get; set; } = "TUnit.Aspire.Test";
 
         [Test]
         public async Task InstantiationTest()

TUnit.Templates.Tests/BasicTemplateTests.cs

@@ -2,11 +2,25 @@
 
 public class BasicTemplateTests : TemplateTestBase
 {
-    protected override string TemplateShortName => "TUnit";
+    protected override string TemplateShortName { get; set; } = "TUnit";
 
     [Test]
     public async Task InstantiationTest()
     {
         await Engine.Execute(Options).ConfigureAwait(false);
     }
+
+    [Test]
+    public async Task InstantiationTestWithFSharp()
+    {
+        TemplateShortName = "TUnit.FSharp";
+        await Engine.Execute(Options).ConfigureAwait(false);
+    }
+
+    [Test]
+    public async Task InstantiationTestWithVB()
+    {
+        TemplateShortName = "TUnit.VB";
+        await Engine.Execute(Options).ConfigureAwait(false);
+    }
 }

TUnit.Templates.Tests/PlaywriteTemplateTests.cs

@@ -2,7 +2,7 @@
 
 public class PlaywriteTemplateTests : TemplateTestBase
 {
-    protected override string TemplateShortName => "TUnit.Playwright";
+    protected override string TemplateShortName { get; set; } = "TUnit.Playwright";
 
     [Test]
     public async Task InstantiationTest()

TUnit.Templates.Tests/Snapshots/InstantiationTestWithFSharp.TUnit.FSharp._.verified/TUnit.FSharp/Data/DataClass.fs

@@ -0,0 +1,15 @@
+namespace TUnit.FSharp
+
+open System
+open System.Threading.Tasks
+open TUnit.Core.Interfaces
+
+type DataClass() =
+    interface IAsyncInitializer with
+        member _.InitializeAsync() : Task =
+            Console.Out.WriteLineAsync("Classes can be injected into tests, and they can perform some initialisation logic such as starting an in-memory server or a test container.")
+
+    interface IAsyncDisposable with
+        member _.DisposeAsync() : ValueTask =
+            ValueTask(Console.Out.WriteLineAsync("And when the class is finished with, we can clean up any resources."))
+

TUnit.Templates.Tests/Snapshots/InstantiationTestWithFSharp.TUnit.FSharp._.verified/TUnit.FSharp/Data/DataGenerator.fs

@@ -0,0 +1,16 @@
+namespace TUnit.FSharp.Data
+
+open System
+open System.Collections.Generic
+open TUnit.Core
+
+type DataGenerator() =
+    inherit DataSourceGeneratorAttribute<int, int, int>()
+
+    override _.GenerateDataSources(_: DataGeneratorMetadata) : IEnumerable<Func<struct (int * int * int)>> =
+        seq {
+            yield Func<struct (int * int * int)>(fun () -> struct (1, 1, 2))
+            yield Func<struct (int * int * int)>(fun () -> struct (1, 2, 3))
+            yield Func<struct (int * int * int)>(fun () -> struct (4, 5, 9))
+        }
+

TUnit.Templates.Tests/Snapshots/InstantiationTestWithFSharp.TUnit.FSharp._.verified/TUnit.FSharp/Data/DependencyInjectionClassConstructor.fs

@@ -0,0 +1,18 @@
+namespace TUnit.FSharp
+
+open System
+open Microsoft.Extensions.DependencyInjection
+open TUnit.Core.Interfaces
+open TUnit.Core
+
+type DependencyInjectionClassConstructor() =
+    let serviceProvider =
+        ServiceCollection()
+            // Register your dependencies here, e.g.:
+            .AddTransient<DataClass>()
+            .BuildServiceProvider()
+
+    interface IClassConstructor with
+        member _.Create(typ: Type, _: ClassConstructorMetadata) : obj =
+            Console.WriteLine("You can also control how your test classes are new'd up, giving you lots of power and the ability to utilise tools such as dependency injection")
+            ActivatorUtilities.GetServiceOrCreateInstance(serviceProvider, typ)

TUnit.Templates.Tests/Snapshots/InstantiationTestWithFSharp.TUnit.FSharp._.verified/TUnit.FSharp/GlobalSetup.fs

@@ -0,0 +1,22 @@
+namespace TUnit.FSharp
+
+// Here you could define global logic that would affect all tests
+
+// You can use attributes at the assembly level to apply to all tests in the assembly
+open System
+open System.Diagnostics.CodeAnalysis
+open TUnit.Core
+
+[<assembly: Retry(3)>]
+[<assembly: ExcludeFromCodeCoverage>]
+do ()
+
+type GlobalHooks() =
+    [<Before(HookType.TestSession)>]
+    static member SetUp() =
+        Console.WriteLine("Or you can define methods that do stuff before...")
+
+    [<After(HookType.TestSession)>]
+    static member CleanUp() =
+        Console.WriteLine("...and after!")
+

TUnit.Templates.Tests/Snapshots/InstantiationTestWithFSharp.TUnit.FSharp._.verified/TUnit.FSharp/TUnit.FSharp.fsproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<LangVersion>latest</LangVersion>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+		<OutputType>Exe</OutputType>
+		<TargetFramework>net8.0</TargetFramework>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.5" />
+		<PackageReference Include="TUnit" Version="0.21.1" />
+		<PackageReference Include="TUnit.Assertions.FSharp" Version="0.21.1" />	
+	</ItemGroup>
+
+	<ItemGroup>
+		<Compile Include="Data\DataClass.fs" />
+		<Compile Include="Data\DataGenerator.fs" />
+		<Compile Include="Data\DependencyInjectionClassConstructor.fs" />
+		<Compile Include="GlobalSetup.fs" />
+		<Compile Include="Tests.fs" />
+		<Compile Include="Tests2.fs" />
+		<Compile Include="Tests3.fs" />
+	</ItemGroup>
+
+</Project>

TUnit.Templates.Tests/Snapshots/InstantiationTestWithFSharp.TUnit.FSharp._.verified/TUnit.FSharp/Tests.fs

@@ -0,0 +1,62 @@
+namespace TUnit.FSharp
+
+open System
+open System.Collections.Generic
+open System.Threading.Tasks
+open TUnit.FSharp.Data
+open TUnit
+open TUnit.Core
+open TUnit.Assertions
+open TUnit.Assertions.Extensions
+open TUnit.Assertions.FSharp.Operations
+
+type Tests() =
+
+    [<Test>]
+    member _.Basic() =
+        Console.WriteLine("This is a basic test")
+
+    [<Test>]
+    [<Arguments(1, 2, 3)>]
+    [<Arguments(2, 3, 5)>]
+    member _.DataDrivenArguments(a: int, b: int, c: int) =
+        async {
+            Console.WriteLine("This one can accept arguments from an attribute")
+            let result = a + b
+            do! check(Assert.That(result).IsEqualTo(c))
+        }
+
+
+    [<Test>]
+    [<MethodDataSource("DataSource")>]
+    member _.MethodDataSource(a: int, b: int, c: int) =
+        async {
+            Console.WriteLine("This one can accept arguments from a method")
+            let result = a + b
+            do! check(Assert.That(result).IsEqualTo(c))
+        }
+
+    [<Test>]
+    [<ClassDataSource(typeof<DataClass>)>]
+    [<ClassDataSource(typeof<DataClass>, Shared = SharedType.PerClass)>]
+    [<ClassDataSource(typeof<DataClass>, Shared = SharedType.PerAssembly)>]
+    [<ClassDataSource(typeof<DataClass>, Shared = SharedType.PerTestSession)>]
+    member _.ClassDataSource(dataClass: DataClass) =
+        Console.WriteLine("This test can accept a class, which can also be pre-initialised before being injected in")
+        Console.WriteLine("These can also be shared among other tests, or new'd up each time, by using the `Shared` property on the attribute")
+
+    [<Test>]
+    [<DataGenerator>]
+    member _.CustomDataGenerator(a: int, b: int, c: int) =
+        async {
+            Console.WriteLine("You can even define your own custom data generators")
+            let result = a + b
+            do! check(Assert.That(result).IsEqualTo(c))
+        }
+
+    static member DataSource() : IEnumerable<struct (int * int * int)> =
+        seq {
+            yield struct (1, 1, 2)
+            yield struct (2, 1, 3)
+            yield struct (3, 1, 4)
+        }

TUnit.Templates.Tests/Snapshots/InstantiationTestWithFSharp.TUnit.FSharp._.verified/TUnit.FSharp/Tests2.fs

@@ -0,0 +1,27 @@
+namespace TUnit.FSharp
+
+open System
+open TUnit.Core
+
+[<Arguments("Hello")>]
+[<Arguments("World")>]
+type MoreTests(title: string) =
+
+    [<Test>]
+    member _.ClassLevelDataRow() =
+        Console.WriteLine(title)
+        Console.WriteLine("Did I forget that data injection works on classes too?")
+
+    [<ClassDataSource(typeof<DataClass>, Shared = SharedType.PerTestSession)>]
+    member val DataClass: DataClass = Unchecked.defaultof<_> with get, set
+
+    [<Test>]
+    [<MatrixDataSource>]
+    member _.Matrices
+        (
+            [<Matrix(1, 2, 3)>] a: int,
+            [<Matrix(true, false)>] b: bool,
+            [<Matrix("A", "B", "C")>] c: string
+        ) =
+        Console.WriteLine("A new test will be created for each data row, whether it's on the class or method level!")
+        Console.WriteLine("Oh and this is a matrix test. That means all combinations of inputs are attempted.")

TUnit.Templates.Tests/Snapshots/InstantiationTestWithFSharp.TUnit.FSharp._.verified/TUnit.FSharp/Tests3.fs

@@ -0,0 +1,15 @@
+namespace TUnit.FSharp
+
+open System
+open TUnit.Core
+
+[<ClassDataSource(typeof<DataClass>)>]
+[<ClassConstructor(typeof<DependencyInjectionClassConstructor>)>]
+type AndEvenMoreTests(dataClass: DataClass) =
+
+    [<Test>]
+    member _.HaveFun() =
+        Console.WriteLine(dataClass)
+        Console.WriteLine("For more information, check out the documentation")
+        Console.WriteLine("https://tunit.dev/")
+

TUnit.Templates.Tests/Snapshots/InstantiationTestWithVB.TUnit.VB._.verified/TUnit.VB/Data/DataClass.vb

@@ -0,0 +1,19 @@
+Imports System
+Imports System.Threading.Tasks
+Imports TUnit.Core.Interfaces
+
+Public Class DataClass
+    Implements IAsyncInitializer, IAsyncDisposable
+
+    Public Function InitializeAsync() As Task Implements IAsyncInitializer.InitializeAsync
+        Return Console.Out.WriteLineAsync("Classes can be injected into tests, and they can perform some initialisation logic such as starting an in-memory server or a test container.")
+    End Function
+
+    Public Function DisposeAsync() As ValueTask Implements IAsyncDisposable.DisposeAsync
+        Return New ValueTask(DisposeAsyncTask())
+    End Function
+
+    Private Async Function DisposeAsyncTask() As Task
+        Await Console.Out.WriteLineAsync("And when the class is finished with, we can clean up any resources.")
+    End Function
+End Class

TUnit.Templates.Tests/Snapshots/InstantiationTestWithVB.TUnit.VB._.verified/TUnit.VB/Data/DataGenerator.vb

@@ -0,0 +1,17 @@
+Imports System
+Imports System.Collections.Generic
+Imports TUnit.Core
+
+Namespace Data
+    Public Class DataGenerator
+        Inherits DataSourceGeneratorAttribute(Of Integer, Integer, Integer)
+
+        Public Overrides Iterator Function GenerateDataSources(dataGeneratorMetadata As DataGeneratorMetadata) As IEnumerable(Of Func(Of (Integer, Integer, Integer)))
+            Yield Function() (1, 1, 2)
+            Yield Function() (1, 2, 3)
+            Yield Function() (4, 5, 9)
+        End Function
+
+    End Class
+End Namespace
+

TUnit.Templates.Tests/Snapshots/InstantiationTestWithVB.TUnit.VB._.verified/TUnit.VB/Data/DependencyInjectionClassConstructor.vb

@@ -0,0 +1,26 @@
+Imports System
+Imports TUnit.Core
+Imports TUnit.Core.Interfaces
+Public Class DependencyInjectionClassConstructor
+    Implements IClassConstructor
+
+    Public Function Create(Of T As Class)(classConstructorMetadata As ClassConstructorMetadata) As T
+        Console.WriteLine("You can also control how your test classes are new'd up, giving you lots of power and the ability to utilise tools such as dependency injection")
+
+        If GetType(T) Is GetType(AndEvenMoreTests) Then
+            Return CType(DirectCast(New AndEvenMoreTests(New DataClass()), Object), T)
+        End If
+
+        Throw New NotImplementedException()
+    End Function
+
+    ' Explicit interface implementation for IClassConstructor.Create(Type, ClassConstructorMetadata)
+    Private Function IClassConstructor_Create(type As Type, classConstructorMetadata As ClassConstructorMetadata) As Object Implements IClassConstructor.Create
+        If type Is GetType(AndEvenMoreTests) Then
+            Return New AndEvenMoreTests(New DataClass())
+        End If
+
+        Throw New NotImplementedException()
+    End Function
+
+End Class

TUnit.Templates.Tests/Snapshots/InstantiationTestWithVB.TUnit.VB._.verified/TUnit.VB/GlobalSetup.vb

@@ -0,0 +1,21 @@
+' Here you could define global logic that would affect all tests
+
+' You can use attributes at the assembly level to apply to all tests in the assembly
+Imports TUnit.Core
+
+<Assembly: Retry(3)>
+<Assembly: CodeAnalysis.ExcludeFromCodeCoverage>
+
+Public Class GlobalHooks
+
+    <Before(HookType.TestSession)>
+    Public Shared Sub SetUp()
+        Console.WriteLine("Or you can define methods that do stuff before...")
+    End Sub
+
+    <After(HookType.TestSession)>
+    Public Shared Sub CleanUp()
+        Console.WriteLine("...and after!")
+    End Sub
+
+End Class

TUnit.Templates.Tests/Snapshots/InstantiationTestWithVB.TUnit.VB._.verified/TUnit.VB/TUnit.VB.vbproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+	  <PackageReference Include="TUnit" Version="0.21.1" />
+  </ItemGroup>
+</Project>