Tests: proceed with TruePath everywhere; add stub for multi-file compilation tests

Author: ForNeVeR

Cesium.CodeGen.Tests/CodeGenNetInteropTests.cs

@@ -5,61 +5,57 @@
 using System.Diagnostics.CodeAnalysis;
 using Cesium.Compiler;
 using Cesium.TestFramework;
+using TruePath;
 using Xunit.Abstractions;
 
 namespace Cesium.CodeGen.Tests;
 
 // TODO[#488]: Make them run in parallel, as all the integration tests
-public class CodeGenNetInteropTests : CodeGenTestBase
+public class CodeGenNetInteropTests(ITestOutputHelper output) : CodeGenTestBase
 {
-    private readonly ITestOutputHelper _output;
-    public CodeGenNetInteropTests(ITestOutputHelper output)
-    {
-        _output = output;
-    }
-
     private async Task DoTest(
         TargetArchitectureSet architecture,
         [StringSyntax("csharp")] string cSharpCode,
         [StringSyntax("cpp")] string cCode)
     {
         var cSharpAssemblyPath = await CSharpCompilationUtil.CompileCSharpAssembly(
-            _output,
+            output,
             CSharpCompilationUtil.DefaultRuntime,
             cSharpCode);
-        var (cesiumAssembly, assemblyContents) = GenerateAssembly(runtime: null, arch: architecture, sources: new[]{cCode}, referencePaths: new[] { cSharpAssemblyPath });
+        var (cesiumAssembly, assemblyContents) = GenerateAssembly(
+            runtime: null,
+            arch: architecture,
+            sources: [cCode],
+            referencePaths: [cSharpAssemblyPath]);
         await VerifyTypes(cesiumAssembly, architecture);
         await VerifyAssemblyRuns(assemblyContents.ToArray(), cSharpAssemblyPath);
     }
 
-    private async Task VerifyAssemblyRuns(byte[] assemblyContentToRun, string referencePath)
+    private async Task VerifyAssemblyRuns(byte[] assemblyContentToRun, AbsolutePath referencePath)
     {
-        var testDirectoryPath = Path.GetTempFileName();
-        File.Delete(testDirectoryPath);
-        Directory.CreateDirectory(testDirectoryPath);
-
+        var testDirectory = Temporary.CreateTempFolder();
         try
         {
-            var assemblyPath = Path.Combine(testDirectoryPath, "EntryPoint.dll");
-            var runtimeConfigPath = Path.ChangeExtension(assemblyPath, ".runtimeconfig.json");
+            var assemblyPath = testDirectory / "EntryPoint.dll";
+            var runtimeConfigPath = Path.ChangeExtension(assemblyPath.Value, ".runtimeconfig.json");
 
-            await File.WriteAllBytesAsync(assemblyPath, assemblyContentToRun);
+            await File.WriteAllBytesAsync(assemblyPath.Value, assemblyContentToRun);
             await File.WriteAllTextAsync(runtimeConfigPath, RuntimeConfig.EmitNet9());
 
             DeployReferenceAssembly(CSharpCompilationUtil.CesiumRuntimeLibraryPath);
             DeployReferenceAssembly(referencePath);
 
-            await ExecUtil.RunToSuccess(_output, "dotnet", testDirectoryPath, new[] { assemblyPath });
+            await ExecUtil.RunToSuccess(output, new LocalPath("dotnet"), testDirectory, [assemblyPath.Value]);
         }
         finally
         {
-            Directory.Delete(testDirectoryPath, recursive: true);
+            Directory.Delete(testDirectory.Value, recursive: true);
         }
 
-        void DeployReferenceAssembly(string assemblyPath)
+        void DeployReferenceAssembly(AbsolutePath assemblyPath)
         {
-            var targetFilePath = Path.Combine(testDirectoryPath, Path.GetFileName(assemblyPath));
-            File.Copy(assemblyPath, targetFilePath);
+            var targetFilePath = testDirectory / assemblyPath.FileName;
+            File.Copy(assemblyPath.Value, targetFilePath.Value);
         }
     }
 

Cesium.CodeGen.Tests/CodeGenTestBase.cs

@@ -28,7 +28,7 @@ protected static AssemblyDefinition GenerateAssembly(TargetRuntimeDescriptor? ru
             runtime,
             @namespace: "",
             globalTypeFqn: "",
-            referencePaths: Array.Empty<string>());
+            referencePaths: []);
         return assembly;
     }
 
@@ -38,7 +38,7 @@ protected static AssemblyDefinition GenerateAssembly(
         string @namespace = "",
         string globalTypeFqn = "", params string[] sources)
     {
-        var (assembly, _) = GenerateAssembly(sources, runtime, arch, @namespace, globalTypeFqn, Array.Empty<string>());
+        var (assembly, _) = GenerateAssembly(sources, runtime, arch, @namespace, globalTypeFqn, []);
         return assembly;
     }
 
@@ -48,7 +48,7 @@ protected static (AssemblyDefinition, byte[]) GenerateAssembly(
         TargetArchitectureSet arch = TargetArchitectureSet.Dynamic,
         string @namespace = "",
         string globalTypeFqn = "",
-        string[]? referencePaths = null)
+        AbsolutePath[]? referencePaths = null)
     {
         var context = CreateAssembly(
             runtime,

Cesium.Compiler.Tests/JsonObjectFileTests.cs

@@ -15,7 +15,4 @@ public void CorrectExtensions(string fileName, bool result) =>
 
     [Fact]
     public void ObjectFileGetsReadCorrectly() => Assert.Fail();
-
-    [Fact]
-    public void CompilationSucceedsForObjectFile() => Assert.Fail("Migrate me to the integration tests");
 }

Cesium.IntegrationTests/Cesium.IntegrationTests.csproj

@@ -30,4 +30,9 @@ SPDX-License-Identifier: MIT
       <ProjectReference Include="..\Cesium.TestFramework\Cesium.TestFramework.csproj" />
     </ItemGroup>
 
+    <ItemGroup>
+      <ClCompile Include="multi-file\function.c" />
+      <ClCompile Include="multi-file\program.c" />
+    </ItemGroup>
+
 </Project>

Cesium.IntegrationTests/IntegrationTestContext.cs

@@ -6,6 +6,7 @@
 using Cesium.Solution.Metadata;
 using Cesium.TestFramework;
 using JetBrains.Annotations;
+using TruePath;
 using Xunit.Abstractions;
 
 namespace Cesium.IntegrationTests;
@@ -22,7 +23,7 @@ public class IntegrationTestContext : IAsyncDisposable
     private bool _initialized;
     private Exception? _initializationException;
 
-    public string? VisualStudioPath { get; private set; }
+    public AbsolutePath? VisualStudioPath { get; private set; }
 
     public async Task WrapTestBody(Func<Task> testBody)
     {
@@ -62,7 +63,7 @@ private async Task InitializeOnce(ITestOutputHelper output)
     {
         if (OperatingSystem.IsWindows())
         {
-            VisualStudioPath = await WindowsEnvUtil.FindVCCompilerInstallationFolder(output);
+            VisualStudioPath = await WindowsEnvUtil.FindVcCompilerInstallationFolder(output);
         }
 
         await BuildRuntime(output);
@@ -76,17 +77,13 @@ public async ValueTask DisposeAsync()
 
     private static async Task BuildRuntime(ITestOutputHelper output)
     {
-        var runtimeProjectFile = Path.Combine(
-            SolutionMetadata.SourceRoot,
-            "Cesium.Runtime/Cesium.Runtime.csproj");
+        var runtimeProjectFile = SolutionMetadata.SourceRoot / "Cesium.Runtime/Cesium.Runtime.csproj";
         await DotNetCliHelper.BuildDotNetProject(output, BuildConfiguration, runtimeProjectFile);
     }
 
     private static async Task BuildCompiler(ITestOutputHelper output)
     {
-        var compilerProjectFile = Path.Combine(
-            SolutionMetadata.SourceRoot,
-            "Cesium.Compiler/Cesium.Compiler.csproj");
+        var compilerProjectFile = SolutionMetadata.SourceRoot / "Cesium.Compiler/Cesium.Compiler.csproj";
         await DotNetCliHelper.BuildDotNetProject(output, BuildConfiguration, compilerProjectFile);
     }
 }