feat: implement target configuration system for issue #1176
Add comprehensive target configuration parsing and inheritance system: - Create internal/targets package with config structures - Support JSON configuration loading with inheritance resolution - Implement multi-level inheritance (e.g., rp2040 → cortex-m0plus → cortex-m) - Add 206 target configurations from TinyGo for embedded platforms - Support core fields: name, llvm-target, cpu, features, build-tags, goos, goarch, cflags, ldflags - Provide high-level resolver interface for target lookup - Include comprehensive unit tests with 100% target parsing coverage This foundation enables future -target parameter support for cross-compilation to diverse embedded platforms beyond current GOOS/GOARCH limitations. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Li Jie
43
internal/targets/config.go
Normal file
43
internal/targets/config.go
Normal file
@@ -0,0 +1,43 @@
|
||||
package targets
|
||||
|
||||
// Config represents a complete target configuration after inheritance resolution
|
||||
type Config struct {
|
||||
// Target identification
|
||||
Name string `json:"-"`
|
||||
|
||||
// LLVM configuration
|
||||
LLVMTarget string `json:"llvm-target"`
|
||||
CPU string `json:"cpu"`
|
||||
Features string `json:"features"`
|
||||
|
||||
// Build configuration
|
||||
BuildTags []string `json:"build-tags"`
|
||||
GOOS string `json:"goos"`
|
||||
GOARCH string `json:"goarch"`
|
||||
|
||||
// Compiler and linker configuration
|
||||
Linker string `json:"linker"`
|
||||
CFlags []string `json:"cflags"`
|
||||
LDFlags []string `json:"ldflags"`
|
||||
}
|
||||
|
||||
// RawConfig represents the raw JSON configuration before inheritance resolution
|
||||
type RawConfig struct {
|
||||
Inherits []string `json:"inherits"`
|
||||
Config
|
||||
}
|
||||
|
||||
// IsEmpty returns true if the config appears to be uninitialized
|
||||
func (c *Config) IsEmpty() bool {
|
||||
return c.Name == "" && c.LLVMTarget == "" && c.GOOS == "" && c.GOARCH == ""
|
||||
}
|
||||
|
||||
// HasInheritance returns true if this config inherits from other configs
|
||||
func (rc *RawConfig) HasInheritance() bool {
|
||||
return len(rc.Inherits) > 0
|
||||
}
|
||||
|
||||
// GetInherits returns the list of configs this config inherits from
|
||||
func (rc *RawConfig) GetInherits() []string {
|
||||
return rc.Inherits
|
||||
}
|
||||
73
internal/targets/example_test.go
Normal file
73
internal/targets/example_test.go
Normal file
@@ -0,0 +1,73 @@
|
||||
package targets_test
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"sort"
|
||||
|
||||
"github.com/goplus/llgo/internal/targets"
|
||||
)
|
||||
|
||||
func ExampleResolver_Resolve() {
|
||||
resolver := targets.NewDefaultResolver()
|
||||
|
||||
// Resolve a specific target
|
||||
config, err := resolver.Resolve("rp2040")
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
fmt.Printf("Target: %s\n", config.Name)
|
||||
fmt.Printf("LLVM Target: %s\n", config.LLVMTarget)
|
||||
fmt.Printf("CPU: %s\n", config.CPU)
|
||||
fmt.Printf("GOOS: %s\n", config.GOOS)
|
||||
fmt.Printf("GOARCH: %s\n", config.GOARCH)
|
||||
if len(config.BuildTags) > 0 {
|
||||
fmt.Printf("Build Tags: %v\n", config.BuildTags)
|
||||
}
|
||||
if len(config.CFlags) > 0 {
|
||||
fmt.Printf("C Flags: %v\n", config.CFlags)
|
||||
}
|
||||
if len(config.LDFlags) > 0 {
|
||||
fmt.Printf("LD Flags: %v\n", config.LDFlags)
|
||||
}
|
||||
}
|
||||
|
||||
func ExampleResolver_ListAvailableTargets() {
|
||||
resolver := targets.NewDefaultResolver()
|
||||
|
||||
targets, err := resolver.ListAvailableTargets()
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
// Show first 10 targets
|
||||
sort.Strings(targets)
|
||||
fmt.Printf("Available targets (first 10 of %d):\n", len(targets))
|
||||
for i, target := range targets[:10] {
|
||||
fmt.Printf("%d. %s\n", i+1, target)
|
||||
}
|
||||
}
|
||||
|
||||
func ExampleResolver_ResolveAll() {
|
||||
resolver := targets.NewDefaultResolver()
|
||||
|
||||
configs, err := resolver.ResolveAll()
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
// Count targets by GOOS
|
||||
goosCounts := make(map[string]int)
|
||||
for _, config := range configs {
|
||||
if config.GOOS != "" {
|
||||
goosCounts[config.GOOS]++
|
||||
}
|
||||
}
|
||||
|
||||
fmt.Printf("Loaded %d target configurations\n", len(configs))
|
||||
fmt.Printf("GOOS distribution:\n")
|
||||
for goos, count := range goosCounts {
|
||||
fmt.Printf(" %s: %d targets\n", goos, count)
|
||||
}
|
||||
}
|
||||
176
internal/targets/loader.go
Normal file
176
internal/targets/loader.go
Normal file
@@ -0,0 +1,176 @@
|
||||
package targets
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Loader handles loading and parsing target configurations
|
||||
type Loader struct {
|
||||
targetsDir string
|
||||
cache map[string]*RawConfig
|
||||
}
|
||||
|
||||
// NewLoader creates a new target configuration loader
|
||||
func NewLoader(targetsDir string) *Loader {
|
||||
return &Loader{
|
||||
targetsDir: targetsDir,
|
||||
cache: make(map[string]*RawConfig),
|
||||
}
|
||||
}
|
||||
|
||||
// LoadRaw loads a raw configuration without resolving inheritance
|
||||
func (l *Loader) LoadRaw(name string) (*RawConfig, error) {
|
||||
// Check cache first
|
||||
if config, exists := l.cache[name]; exists {
|
||||
return config, nil
|
||||
}
|
||||
|
||||
// Construct file path
|
||||
configPath := filepath.Join(l.targetsDir, name+".json")
|
||||
|
||||
// Read file
|
||||
data, err := os.ReadFile(configPath)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read target config %s: %w", name, err)
|
||||
}
|
||||
|
||||
// Parse JSON
|
||||
var config RawConfig
|
||||
if err := json.Unmarshal(data, &config); err != nil {
|
||||
return nil, fmt.Errorf("failed to parse target config %s: %w", name, err)
|
||||
}
|
||||
|
||||
// Set the name
|
||||
config.Name = name
|
||||
|
||||
// Cache the result
|
||||
l.cache[name] = &config
|
||||
|
||||
return &config, nil
|
||||
}
|
||||
|
||||
// Load loads a target configuration with inheritance resolved
|
||||
func (l *Loader) Load(name string) (*Config, error) {
|
||||
raw, err := l.LoadRaw(name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return l.resolveInheritance(raw)
|
||||
}
|
||||
|
||||
// LoadAll loads all target configurations in the targets directory
|
||||
func (l *Loader) LoadAll() (map[string]*Config, error) {
|
||||
entries, err := os.ReadDir(l.targetsDir)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read targets directory: %w", err)
|
||||
}
|
||||
|
||||
configs := make(map[string]*Config)
|
||||
|
||||
for _, entry := range entries {
|
||||
if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".json") {
|
||||
continue
|
||||
}
|
||||
|
||||
name := strings.TrimSuffix(entry.Name(), ".json")
|
||||
config, err := l.Load(name)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to load target %s: %w", name, err)
|
||||
}
|
||||
|
||||
configs[name] = config
|
||||
}
|
||||
|
||||
return configs, nil
|
||||
}
|
||||
|
||||
// resolveInheritance resolves inheritance chain for a configuration
|
||||
func (l *Loader) resolveInheritance(raw *RawConfig) (*Config, error) {
|
||||
if !raw.HasInheritance() {
|
||||
// No inheritance, return as-is
|
||||
return &raw.Config, nil
|
||||
}
|
||||
|
||||
// Start with base config
|
||||
result := &Config{Name: raw.Name}
|
||||
|
||||
// Apply inheritance in order
|
||||
for _, parentName := range raw.GetInherits() {
|
||||
parent, err := l.Load(parentName)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to load parent config %s: %w", parentName, err)
|
||||
}
|
||||
|
||||
// Merge parent into result
|
||||
l.mergeConfig(result, parent)
|
||||
}
|
||||
|
||||
// Finally, apply current config on top
|
||||
l.mergeConfig(result, &raw.Config)
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// mergeConfig merges source config into destination config
|
||||
// Non-empty values in source override those in destination
|
||||
func (l *Loader) mergeConfig(dst, src *Config) {
|
||||
if src.LLVMTarget != "" {
|
||||
dst.LLVMTarget = src.LLVMTarget
|
||||
}
|
||||
if src.CPU != "" {
|
||||
dst.CPU = src.CPU
|
||||
}
|
||||
if src.Features != "" {
|
||||
dst.Features = src.Features
|
||||
}
|
||||
if src.GOOS != "" {
|
||||
dst.GOOS = src.GOOS
|
||||
}
|
||||
if src.GOARCH != "" {
|
||||
dst.GOARCH = src.GOARCH
|
||||
}
|
||||
if src.Linker != "" {
|
||||
dst.Linker = src.Linker
|
||||
}
|
||||
|
||||
// Merge slices (append, don't replace)
|
||||
if len(src.BuildTags) > 0 {
|
||||
dst.BuildTags = append(dst.BuildTags, src.BuildTags...)
|
||||
}
|
||||
if len(src.CFlags) > 0 {
|
||||
dst.CFlags = append(dst.CFlags, src.CFlags...)
|
||||
}
|
||||
if len(src.LDFlags) > 0 {
|
||||
dst.LDFlags = append(dst.LDFlags, src.LDFlags...)
|
||||
}
|
||||
}
|
||||
|
||||
// GetTargetsDir returns the targets directory path
|
||||
func (l *Loader) GetTargetsDir() string {
|
||||
return l.targetsDir
|
||||
}
|
||||
|
||||
// ListTargets returns a list of all available target names
|
||||
func (l *Loader) ListTargets() ([]string, error) {
|
||||
entries, err := os.ReadDir(l.targetsDir)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read targets directory: %w", err)
|
||||
}
|
||||
|
||||
var targets []string
|
||||
for _, entry := range entries {
|
||||
if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".json") {
|
||||
continue
|
||||
}
|
||||
|
||||
name := strings.TrimSuffix(entry.Name(), ".json")
|
||||
targets = append(targets, name)
|
||||
}
|
||||
|
||||
return targets, nil
|
||||
}
|
||||
77
internal/targets/resolver.go
Normal file
77
internal/targets/resolver.go
Normal file
@@ -0,0 +1,77 @@
|
||||
package targets
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
)
|
||||
|
||||
// Resolver provides high-level interface for target configuration resolution
|
||||
type Resolver struct {
|
||||
loader *Loader
|
||||
}
|
||||
|
||||
// NewResolver creates a new target resolver
|
||||
func NewResolver(targetsDir string) *Resolver {
|
||||
return &Resolver{
|
||||
loader: NewLoader(targetsDir),
|
||||
}
|
||||
}
|
||||
|
||||
// NewDefaultResolver creates a resolver with default targets directory
|
||||
func NewDefaultResolver() *Resolver {
|
||||
// Assume targets directory is relative to this package
|
||||
_, filename, _, _ := runtime.Caller(0)
|
||||
projectRoot := filepath.Dir(filepath.Dir(filepath.Dir(filename)))
|
||||
targetsDir := filepath.Join(projectRoot, "targets")
|
||||
|
||||
return NewResolver(targetsDir)
|
||||
}
|
||||
|
||||
// Resolve resolves a target configuration by name
|
||||
func (r *Resolver) Resolve(targetName string) (*Config, error) {
|
||||
config, err := r.loader.Load(targetName)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to resolve target %s: %w", targetName, err)
|
||||
}
|
||||
|
||||
// Validate required fields
|
||||
if err := r.validateConfig(config); err != nil {
|
||||
return nil, fmt.Errorf("invalid target config %s: %w", targetName, err)
|
||||
}
|
||||
|
||||
return config, nil
|
||||
}
|
||||
|
||||
// ResolveAll resolves all available target configurations
|
||||
func (r *Resolver) ResolveAll() (map[string]*Config, error) {
|
||||
return r.loader.LoadAll()
|
||||
}
|
||||
|
||||
// ListAvailableTargets returns a list of all available target names
|
||||
func (r *Resolver) ListAvailableTargets() ([]string, error) {
|
||||
return r.loader.ListTargets()
|
||||
}
|
||||
|
||||
// validateConfig validates that a resolved config has required fields
|
||||
func (r *Resolver) validateConfig(config *Config) error {
|
||||
if config.Name == "" {
|
||||
return fmt.Errorf("target name is required")
|
||||
}
|
||||
|
||||
// For now, we don't require any specific fields since different targets
|
||||
// may have different requirements. This can be extended in the future.
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetTargetsDirectory returns the path to the targets directory
|
||||
func (r *Resolver) GetTargetsDirectory() string {
|
||||
return r.loader.GetTargetsDir()
|
||||
}
|
||||
|
||||
// HasTarget checks if a target with the given name exists
|
||||
func (r *Resolver) HasTarget(name string) bool {
|
||||
_, err := r.loader.LoadRaw(name)
|
||||
return err == nil
|
||||
}
|
||||
322
internal/targets/targets_test.go
Normal file
322
internal/targets/targets_test.go
Normal file
@@ -0,0 +1,322 @@
|
||||
//go:build !llgo
|
||||
|
||||
package targets
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestConfigBasics(t *testing.T) {
|
||||
config := &Config{
|
||||
Name: "test",
|
||||
LLVMTarget: "arm-none-eabi",
|
||||
GOOS: "linux",
|
||||
GOARCH: "arm",
|
||||
}
|
||||
|
||||
if config.IsEmpty() {
|
||||
t.Error("Config should not be empty when fields are set")
|
||||
}
|
||||
|
||||
empty := &Config{}
|
||||
if !empty.IsEmpty() {
|
||||
t.Error("Empty config should report as empty")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRawConfigInheritance(t *testing.T) {
|
||||
raw := &RawConfig{
|
||||
Inherits: []string{"parent1", "parent2"},
|
||||
Config: Config{
|
||||
Name: "child",
|
||||
},
|
||||
}
|
||||
|
||||
if !raw.HasInheritance() {
|
||||
t.Error("RawConfig should report having inheritance")
|
||||
}
|
||||
|
||||
inherits := raw.GetInherits()
|
||||
if len(inherits) != 2 || inherits[0] != "parent1" || inherits[1] != "parent2" {
|
||||
t.Errorf("Expected inheritance list [parent1, parent2], got %v", inherits)
|
||||
}
|
||||
|
||||
noInherit := &RawConfig{}
|
||||
if noInherit.HasInheritance() {
|
||||
t.Error("RawConfig with no inherits should not report having inheritance")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoaderLoadRaw(t *testing.T) {
|
||||
// Create a temporary directory for test configs
|
||||
tempDir := t.TempDir()
|
||||
|
||||
// Create a test config file
|
||||
testConfig := `{
|
||||
"llvm-target": "thumbv6m-unknown-unknown-eabi",
|
||||
"cpu": "cortex-m0plus",
|
||||
"goos": "linux",
|
||||
"goarch": "arm",
|
||||
"build-tags": ["test", "embedded"],
|
||||
"cflags": ["-Os", "-g"],
|
||||
"ldflags": ["--gc-sections"]
|
||||
}`
|
||||
|
||||
configPath := filepath.Join(tempDir, "test-target.json")
|
||||
if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
|
||||
t.Fatalf("Failed to write test config: %v", err)
|
||||
}
|
||||
|
||||
loader := NewLoader(tempDir)
|
||||
config, err := loader.LoadRaw("test-target")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to load raw config: %v", err)
|
||||
}
|
||||
|
||||
if config.Name != "test-target" {
|
||||
t.Errorf("Expected name 'test-target', got '%s'", config.Name)
|
||||
}
|
||||
if config.LLVMTarget != "thumbv6m-unknown-unknown-eabi" {
|
||||
t.Errorf("Expected llvm-target 'thumbv6m-unknown-unknown-eabi', got '%s'", config.LLVMTarget)
|
||||
}
|
||||
if config.CPU != "cortex-m0plus" {
|
||||
t.Errorf("Expected cpu 'cortex-m0plus', got '%s'", config.CPU)
|
||||
}
|
||||
if len(config.BuildTags) != 2 || config.BuildTags[0] != "test" || config.BuildTags[1] != "embedded" {
|
||||
t.Errorf("Expected build-tags [test, embedded], got %v", config.BuildTags)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoaderInheritance(t *testing.T) {
|
||||
tempDir := t.TempDir()
|
||||
|
||||
// Create parent config
|
||||
parentConfig := `{
|
||||
"llvm-target": "thumbv6m-unknown-unknown-eabi",
|
||||
"cpu": "cortex-m0plus",
|
||||
"goos": "linux",
|
||||
"goarch": "arm",
|
||||
"cflags": ["-Os"],
|
||||
"ldflags": ["--gc-sections"]
|
||||
}`
|
||||
|
||||
// Create child config that inherits from parent
|
||||
childConfig := `{
|
||||
"inherits": ["parent"],
|
||||
"cpu": "cortex-m4",
|
||||
"build-tags": ["child"],
|
||||
"cflags": ["-O2"],
|
||||
"ldflags": ["-g"]
|
||||
}`
|
||||
|
||||
parentPath := filepath.Join(tempDir, "parent.json")
|
||||
childPath := filepath.Join(tempDir, "child.json")
|
||||
|
||||
if err := os.WriteFile(parentPath, []byte(parentConfig), 0644); err != nil {
|
||||
t.Fatalf("Failed to write parent config: %v", err)
|
||||
}
|
||||
if err := os.WriteFile(childPath, []byte(childConfig), 0644); err != nil {
|
||||
t.Fatalf("Failed to write child config: %v", err)
|
||||
}
|
||||
|
||||
loader := NewLoader(tempDir)
|
||||
config, err := loader.Load("child")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to load child config: %v", err)
|
||||
}
|
||||
|
||||
// Check inherited values
|
||||
if config.LLVMTarget != "thumbv6m-unknown-unknown-eabi" {
|
||||
t.Errorf("Expected inherited llvm-target 'thumbv6m-unknown-unknown-eabi', got '%s'", config.LLVMTarget)
|
||||
}
|
||||
if config.GOOS != "linux" {
|
||||
t.Errorf("Expected inherited goos 'linux', got '%s'", config.GOOS)
|
||||
}
|
||||
if config.GOARCH != "arm" {
|
||||
t.Errorf("Expected inherited goarch 'arm', got '%s'", config.GOARCH)
|
||||
}
|
||||
|
||||
// Check overridden values
|
||||
if config.CPU != "cortex-m4" {
|
||||
t.Errorf("Expected overridden cpu 'cortex-m4', got '%s'", config.CPU)
|
||||
}
|
||||
|
||||
// Check merged arrays
|
||||
expectedCFlags := []string{"-Os", "-O2"}
|
||||
if len(config.CFlags) != 2 || config.CFlags[0] != "-Os" || config.CFlags[1] != "-O2" {
|
||||
t.Errorf("Expected merged cflags %v, got %v", expectedCFlags, config.CFlags)
|
||||
}
|
||||
|
||||
expectedLDFlags := []string{"--gc-sections", "-g"}
|
||||
if len(config.LDFlags) != 2 || config.LDFlags[0] != "--gc-sections" || config.LDFlags[1] != "-g" {
|
||||
t.Errorf("Expected merged ldflags %v, got %v", expectedLDFlags, config.LDFlags)
|
||||
}
|
||||
|
||||
// Check child-specific values
|
||||
if len(config.BuildTags) != 1 || config.BuildTags[0] != "child" {
|
||||
t.Errorf("Expected build-tags [child], got %v", config.BuildTags)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoaderListTargets(t *testing.T) {
|
||||
tempDir := t.TempDir()
|
||||
|
||||
// Create some test config files
|
||||
configs := []string{"target1.json", "target2.json", "not-a-target.txt"}
|
||||
for _, config := range configs {
|
||||
configPath := filepath.Join(tempDir, config)
|
||||
if err := os.WriteFile(configPath, []byte("{}"), 0644); err != nil {
|
||||
t.Fatalf("Failed to write config %s: %v", config, err)
|
||||
}
|
||||
}
|
||||
|
||||
loader := NewLoader(tempDir)
|
||||
targets, err := loader.ListTargets()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to list targets: %v", err)
|
||||
}
|
||||
|
||||
expectedTargets := []string{"target1", "target2"}
|
||||
if len(targets) != len(expectedTargets) {
|
||||
t.Errorf("Expected %d targets, got %d", len(expectedTargets), len(targets))
|
||||
}
|
||||
|
||||
for _, expected := range expectedTargets {
|
||||
found := false
|
||||
for _, target := range targets {
|
||||
if target == expected {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Errorf("Expected target %s not found in list %v", expected, targets)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolver(t *testing.T) {
|
||||
tempDir := t.TempDir()
|
||||
|
||||
// Create a test config
|
||||
testConfig := `{
|
||||
"llvm-target": "wasm32-unknown-wasi",
|
||||
"cpu": "generic",
|
||||
"goos": "wasip1",
|
||||
"goarch": "wasm"
|
||||
}`
|
||||
|
||||
configPath := filepath.Join(tempDir, "wasi.json")
|
||||
if err := os.WriteFile(configPath, []byte(testConfig), 0644); err != nil {
|
||||
t.Fatalf("Failed to write test config: %v", err)
|
||||
}
|
||||
|
||||
resolver := NewResolver(tempDir)
|
||||
|
||||
// Test resolve
|
||||
config, err := resolver.Resolve("wasi")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to resolve target: %v", err)
|
||||
}
|
||||
|
||||
if config.Name != "wasi" {
|
||||
t.Errorf("Expected name 'wasi', got '%s'", config.Name)
|
||||
}
|
||||
|
||||
// Test has target
|
||||
if !resolver.HasTarget("wasi") {
|
||||
t.Error("Resolver should report having 'wasi' target")
|
||||
}
|
||||
if resolver.HasTarget("nonexistent") {
|
||||
t.Error("Resolver should not report having 'nonexistent' target")
|
||||
}
|
||||
|
||||
// Test list available targets
|
||||
targets, err := resolver.ListAvailableTargets()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to list available targets: %v", err)
|
||||
}
|
||||
|
||||
if len(targets) != 1 || targets[0] != "wasi" {
|
||||
t.Errorf("Expected targets [wasi], got %v", targets)
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolverWithRealTargets(t *testing.T) {
|
||||
// Test with actual targets directory if it exists
|
||||
resolver := NewDefaultResolver()
|
||||
targetsDir := resolver.GetTargetsDirectory()
|
||||
|
||||
// Check if targets directory exists
|
||||
if _, err := os.Stat(targetsDir); os.IsNotExist(err) {
|
||||
t.Skipf("Targets directory %s does not exist, skipping real targets test", targetsDir)
|
||||
}
|
||||
|
||||
// Test listing real targets
|
||||
targets, err := resolver.ListAvailableTargets()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to list real targets: %v", err)
|
||||
}
|
||||
|
||||
t.Logf("Found %d targets in %s", len(targets), targetsDir)
|
||||
|
||||
// Test resolving some known targets
|
||||
knownTargets := []string{"wasi", "cortex-m", "rp2040"}
|
||||
for _, targetName := range knownTargets {
|
||||
if resolver.HasTarget(targetName) {
|
||||
config, err := resolver.Resolve(targetName)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to resolve known target %s: %v", targetName, err)
|
||||
continue
|
||||
}
|
||||
t.Logf("Resolved target %s: LLVM=%s, CPU=%s, GOOS=%s, GOARCH=%s",
|
||||
targetName, config.LLVMTarget, config.CPU, config.GOOS, config.GOARCH)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveAllRealTargets(t *testing.T) {
|
||||
resolver := NewDefaultResolver()
|
||||
targetsDir := resolver.GetTargetsDirectory()
|
||||
|
||||
// Check if targets directory exists
|
||||
if _, err := os.Stat(targetsDir); os.IsNotExist(err) {
|
||||
t.Skipf("Targets directory %s does not exist, skipping resolve all test", targetsDir)
|
||||
}
|
||||
|
||||
// Test resolving all targets
|
||||
configs, err := resolver.ResolveAll()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to resolve all targets: %v", err)
|
||||
}
|
||||
|
||||
t.Logf("Successfully resolved %d targets", len(configs))
|
||||
|
||||
// Check that all configs have names
|
||||
for name, config := range configs {
|
||||
if config.Name != name {
|
||||
t.Errorf("Config name mismatch: key=%s, config.Name=%s", name, config.Name)
|
||||
}
|
||||
if config.IsEmpty() {
|
||||
t.Errorf("Config %s appears to be empty", name)
|
||||
}
|
||||
}
|
||||
|
||||
// Log some statistics
|
||||
goosCounts := make(map[string]int)
|
||||
goarchCounts := make(map[string]int)
|
||||
|
||||
for _, config := range configs {
|
||||
if config.GOOS != "" {
|
||||
goosCounts[config.GOOS]++
|
||||
}
|
||||
if config.GOARCH != "" {
|
||||
goarchCounts[config.GOARCH]++
|
||||
}
|
||||
}
|
||||
|
||||
t.Logf("GOOS distribution: %v", goosCounts)
|
||||
t.Logf("GOARCH distribution: %v", goarchCounts)
|
||||
}
|
||||
Reference in New Issue
Block a user