1. New build system

Reviewed-on: #1

runner/compiler_test.go

@@ -0,0 +1,293 @@
+package runner
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/Mond1c/judge/dsl"
+)
+
+func TestResolveToolchainKnown(t *testing.T) {
+	cases := []struct {
+		in        string
+		wantClass CompilerClass
+		wantName  string
+	}{
+		{"gcc", CompilerGNU, "gcc"},
+		{"g++", CompilerGNU, "gcc"},
+		{"clang", CompilerGNU, "clang"},
+		{"clang++", CompilerGNU, "clang"},
+		{"cl", CompilerMSVC, "msvc"},
+		{"cl.exe", CompilerMSVC, "msvc"},
+		{"msvc", CompilerMSVC, "msvc"},
+		{"clang-cl", CompilerMSVC, "clang-cl"},
+		{"cc", CompilerGNU, "cc"},
+	}
+	for _, c := range cases {
+		t.Run(c.in, func(t *testing.T) {
+			tc := ResolveToolchain(c.in)
+			if tc.Class != c.wantClass {
+				t.Errorf("class: got %v, want %v", tc.Class, c.wantClass)
+			}
+			if tc.Name != c.wantName {
+				t.Errorf("name: got %q, want %q", tc.Name, c.wantName)
+			}
+		})
+	}
+}
+
+func TestResolveToolchainSpec(t *testing.T) {
+	cases := []struct {
+		name      string
+		spec      dsl.ToolchainSpec
+		wantClass CompilerClass
+		wantBin   string
+		wantName  string
+	}{
+		{
+			"gcc inferred",
+			dsl.ToolchainSpec{Name: "gcc", Platforms: []string{"linux"}},
+			CompilerGNU, "gcc", "gcc",
+		},
+		{
+			"msvc inferred",
+			dsl.ToolchainSpec{Name: "msvc", Platforms: []string{"windows"}},
+			CompilerMSVC, "cl", "msvc",
+		},
+		{
+			"nvcc with explicit class",
+			dsl.ToolchainSpec{Name: "nvcc", Platforms: []string{"linux"}, Class: "gnu"},
+			CompilerGNU, "nvcc", "nvcc",
+		},
+		{
+			"custom binary override",
+			dsl.ToolchainSpec{Name: "clang", Platforms: []string{"linux", "windows"}, Binary: "clang-17"},
+			CompilerGNU, "clang-17", "clang",
+		},
+		{
+			"unknown name, explicit class",
+			dsl.ToolchainSpec{Name: "hipcc", Platforms: []string{"linux"}, Class: "gnu"},
+			CompilerGNU, "hipcc", "hipcc",
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := ResolveToolchainSpec(&c.spec)
+			if got.Class != c.wantClass {
+				t.Errorf("class: got %v, want %v", got.Class, c.wantClass)
+			}
+			if got.Binary != c.wantBin {
+				t.Errorf("binary: got %q, want %q", got.Binary, c.wantBin)
+			}
+			if got.Name != c.wantName {
+				t.Errorf("name: got %q, want %q", got.Name, c.wantName)
+			}
+		})
+	}
+}
+
+func TestResolveToolchainUnknownFallsBackToGNU(t *testing.T) {
+	tc := ResolveToolchain("gcc-13")
+	if tc.Class != CompilerGNU {
+		t.Errorf("unknown compiler should fall back to GNU, got %v", tc.Class)
+	}
+	if tc.Binary != "gcc-13" {
+		t.Errorf("binary should preserve the original string, got %q", tc.Binary)
+	}
+	if tc.Name != "gcc-13" {
+		t.Errorf("name should be the lowercased original, got %q", tc.Name)
+	}
+}
+
+func TestCompileGNURelease(t *testing.T) {
+	cfg := dsl.BuildConfig{
+		Language: "c",
+		Standard: "c11",
+		Sources:  []string{"solution.c"},
+		Profile:  dsl.ProfileRelease,
+		Warnings: dsl.WarningsStrict,
+	}
+	tc := Toolchain{Class: CompilerGNU, Binary: "gcc", Name: "gcc"}
+	argv, err := Compile(cfg, tc, "solution")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []string{"gcc", "-std=c11", "-O2", "-Wall", "-Wextra", "solution.c", "-o", "solution"}
+	if !reflect.DeepEqual(argv, want) {
+		t.Errorf("argv =\n  %v\nwant\n  %v", argv, want)
+	}
+}
+
+func TestCompileGNUDebug(t *testing.T) {
+	cfg := dsl.BuildConfig{
+		Standard: "c11",
+		Sources:  []string{"a.c", "b.c"},
+		Profile:  dsl.ProfileDebug,
+	}
+	tc := Toolchain{Class: CompilerGNU, Binary: "gcc"}
+	argv, _ := Compile(cfg, tc, "out")
+	if !containsSubsequence(argv, []string{"-O0", "-g"}) {
+		t.Errorf("debug flags missing: %v", argv)
+	}
+	if !containsSubsequence(argv, []string{"a.c", "b.c", "-o", "out"}) {
+		t.Errorf("sources and output order wrong: %v", argv)
+	}
+}
+
+func TestCompileGNUSanitized(t *testing.T) {
+	cfg := dsl.BuildConfig{
+		Standard: "c11",
+		Sources:  []string{"s.c"},
+		Profile:  dsl.ProfileSanitized,
+		Sanitize: []string{"address", "undefined"},
+	}
+	tc := Toolchain{Class: CompilerGNU, Binary: "clang"}
+	argv, _ := Compile(cfg, tc, "s")
+	joined := strings.Join(argv, " ")
+	if !strings.Contains(joined, "-fsanitize=address,undefined") {
+		t.Errorf("sanitize flag missing: %v", argv)
+	}
+	if !strings.Contains(joined, "-O1") {
+		t.Errorf("-O1 missing for sanitized profile: %v", argv)
+	}
+}
+
+func TestCompileGNUIncludesAndDefinesAndLink(t *testing.T) {
+	cfg := dsl.BuildConfig{
+		Sources:  []string{"m.c"},
+		Includes: []string{"include", "vendor/inc"},
+		Defines:  map[string]string{"FOO": "1", "BAR": ""},
+		Link:     []string{"m", "pthread"},
+		Extra:    []string{"-fno-strict-aliasing"},
+	}
+	tc := Toolchain{Class: CompilerGNU, Binary: "gcc"}
+	argv, _ := Compile(cfg, tc, "out")
+
+	joined := strings.Join(argv, " ")
+	for _, want := range []string{"-Iinclude", "-Ivendor/inc", "-DFOO=1", "-DBAR", "-lm", "-lpthread", "-fno-strict-aliasing"} {
+		if !strings.Contains(joined, want) {
+			t.Errorf("missing %q in %v", want, argv)
+		}
+	}
+
+	oIdx := indexOf(argv, "-o")
+	lmIdx := indexOf(argv, "-lm")
+	if oIdx == -1 || lmIdx == -1 || lmIdx < oIdx {
+		t.Errorf("-lm must come after -o: %v", argv)
+	}
+}
+
+func TestCompileGNUDefinesOrderDeterministic(t *testing.T) {
+	cfg := dsl.BuildConfig{
+		Sources: []string{"s.c"},
+		Defines: map[string]string{"Z": "1", "A": "2", "M": "3"},
+	}
+	tc := Toolchain{Class: CompilerGNU, Binary: "gcc"}
+	argv1, _ := Compile(cfg, tc, "s")
+	for i := 0; i < 20; i++ {
+		argv2, _ := Compile(cfg, tc, "s")
+		if !reflect.DeepEqual(argv1, argv2) {
+			t.Fatalf("defines order not deterministic:\n  %v\n  %v", argv1, argv2)
+		}
+	}
+}
+
+func TestCompileMSVCRelease(t *testing.T) {
+	cfg := dsl.BuildConfig{
+		Standard: "c11",
+		Sources:  []string{"solution.c"},
+		Profile:  dsl.ProfileRelease,
+		Warnings: dsl.WarningsStrict,
+	}
+	tc := Toolchain{Class: CompilerMSVC, Binary: "cl", Name: "msvc"}
+	argv, _ := Compile(cfg, tc, "solution.exe")
+	want := []string{"cl", "/nologo", "/std:c11", "/O2", "/W4", "solution.c", "/Fe:solution.exe"}
+	if !reflect.DeepEqual(argv, want) {
+		t.Errorf("argv =\n  %v\nwant\n  %v", argv, want)
+	}
+}
+
+func TestCompileMSVCDebug(t *testing.T) {
+	cfg := dsl.BuildConfig{
+		Sources: []string{"s.c"},
+		Profile: dsl.ProfileDebug,
+	}
+	tc := Toolchain{Class: CompilerMSVC, Binary: "cl"}
+	argv, _ := Compile(cfg, tc, "s.exe")
+	joined := strings.Join(argv, " ")
+	for _, want := range []string{"/Od", "/Zi"} {
+		if !strings.Contains(joined, want) {
+			t.Errorf("missing %q in %v", want, argv)
+		}
+	}
+}
+
+func TestCompileMSVCSanitizedAddressOnly(t *testing.T) {
+	cfg := dsl.BuildConfig{
+		Sources:  []string{"s.c"},
+		Profile:  dsl.ProfileSanitized,
+		Sanitize: []string{"address", "undefined", "thread"},
+	}
+	tc := Toolchain{Class: CompilerMSVC, Binary: "cl"}
+	argv, _ := Compile(cfg, tc, "s.exe")
+	joined := strings.Join(argv, " ")
+	if !strings.Contains(joined, "/fsanitize=address") {
+		t.Errorf("msvc should emit /fsanitize=address for sanitized profile: %v", argv)
+	}
+	if strings.Contains(joined, "undefined") || strings.Contains(joined, "thread") {
+		t.Errorf("msvc should drop unsupported sanitizers, got: %v", argv)
+	}
+}
+
+func TestCompileMSVCIncludesAndDefines(t *testing.T) {
+	cfg := dsl.BuildConfig{
+		Sources:  []string{"m.c"},
+		Includes: []string{"include"},
+		Defines:  map[string]string{"FOO": "1", "BAR": ""},
+	}
+	tc := Toolchain{Class: CompilerMSVC, Binary: "cl"}
+	argv, _ := Compile(cfg, tc, "m.exe")
+	joined := strings.Join(argv, " ")
+	for _, want := range []string{"/Iinclude", "/DFOO=1", "/DBAR"} {
+		if !strings.Contains(joined, want) {
+			t.Errorf("missing %q in %v", want, argv)
+		}
+	}
+}
+
+func TestCompileUnknownClassErrors(t *testing.T) {
+	cfg := dsl.BuildConfig{Sources: []string{"s.c"}}
+	tc := Toolchain{Class: CompilerUnknown, Binary: "weird"}
+	if _, err := Compile(cfg, tc, "s"); err == nil {
+		t.Error("expected error for unknown compiler class")
+	}
+}
+
+func containsSubsequence(haystack, needle []string) bool {
+	if len(needle) == 0 {
+		return true
+	}
+	for i := 0; i+len(needle) <= len(haystack); i++ {
+		match := true
+		for j := range needle {
+			if haystack[i+j] != needle[j] {
+				match = false
+				break
+			}
+		}
+		if match {
+			return true
+		}
+	}
+	return false
+}
+
+func indexOf(xs []string, x string) int {
+	for i, v := range xs {
+		if v == x {
+			return i
+		}
+	}
+	return -1
+}