hakurei/internal/rosa/rosa_test.go

package rosa_test

import (
	"context"
	"log"
	"os"
	"os/signal"
	"sync"
	"syscall"
	"testing"

	"hakurei.app/check"
	"hakurei.app/container"
	"hakurei.app/internal/pkg"
	"hakurei.app/internal/rosa"
	"hakurei.app/message"
)

var (
	// skipBuildTest caches whether build tests are skipped.
	skipBuildTest bool
	// buildTestCache is populated by getCache and must not be accessed directly.
	buildTestCache *pkg.Cache
	// buildTestCacheCancel cancels buildTestCache.
	buildTestCacheCancel context.CancelFunc
	// buildTestCacheOnce synchronises access to buildTestCache.
	buildTestCacheOnce sync.Once
)

func TestMain(m *testing.M) {
	container.TryArgv0(nil)

	code := m.Run()
	if buildTestCache != nil {
		buildTestCacheCancel()
		buildTestCache.Close()
	}
	os.Exit(code)
}

func getCache(t *testing.T) *pkg.Cache {
	t.Helper()
	const env = "ROSA_BUILD_TEST_CACHE_DIR"

	if !testing.Verbose() {
		t.Skip("verbose flag not set")
	}

	buildTestCacheOnce.Do(func() {
		if p, ok := os.LookupEnv(env); !ok {
			skipBuildTest = true
			return
		} else if a, err := check.NewAbs(p); err != nil {
			t.Fatal(err)
		} else {
			var ctx context.Context
			ctx, buildTestCacheCancel = signal.NotifyContext(context.Background(),
				syscall.SIGINT, syscall.SIGTERM)

			msg := message.New(log.New(os.Stderr, "rosa: ", 0))
			msg.SwapVerbose(true)

			if buildTestCache, err = pkg.Open(ctx, msg, 0, 0, a); err != nil {
				t.Fatal(err)
			}
		}
	})

	if skipBuildTest {
		t.Skip(env + " not set")
	}
	return buildTestCache
}

func TestCureAll(t *testing.T) {
	cache := getCache(t)
	t.Parallel()

	for i := range rosa.PresetEnd {
		p := rosa.PArtifact(i)
		meta := rosa.GetMetadata(p)
		a := rosa.Std.Load(p)
		t.Run(meta.Name, func(t *testing.T) {
			t.Parallel()

			if pathname, _, err := cache.Cure(a); err != nil {
				t.Fatal(err)
			} else {
				t.Log(pathname)
			}
		})
	}
}

func BenchmarkStage3(b *testing.B) {
	for b.Loop() {
		rosa.Std.Load(rosa.LLVMClang)

		b.StopTimer()
		rosa.DropCaches()
		b.StartTimer()
	}
}