scripts/cog/ide_query/analyzer_test.go - fuchsia.git - Git at Google

 // Copyright 2026 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package main

 import (
 	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
 	"reflect"
 	"strings"
 	"testing"
 )

 func TestSplitCommand(t *testing.T) {
 	tests := []struct {
 		cmd      string
 		expected []string
 	}{
 		{
 			cmd:      "clang++ -o obj/file.o -c file.cc",
 			expected: []string{"clang++", "-o", "obj/file.o", "-c", "file.cc"},
 		},
 		{
 			cmd:      `clang++ "-DQUOTED_ARG" -o "obj/path with spaces.o"`,
 			expected: []string{"clang++", "-DQUOTED_ARG", "-o", "obj/path with spaces.o"},
 		},
 		{
 			cmd:      `clang++ 'single quoted' -DFOO=\"bar\"`,
 			expected: []string{"clang++", "single quoted", "-DFOO=\"bar\""},
 		},
 		{
 			cmd:      "arg1\\ with\\ space arg2",
 			expected: []string{"arg1 with space", "arg2"},
 		},
 	}

 	for _, test := range tests {
 		result := splitCommand(test.cmd)
 		if !reflect.DeepEqual(result, test.expected) {
 			t.Errorf("splitCommand(%q) = %v; want %v", test.cmd, result, test.expected)
 		}
 	}
 }

 func TestExtractOutput(t *testing.T) {
 	tests := []struct {
 		cmd      CompileCommand
 		expected string
 	}{
 		{
 			cmd: CompileCommand{
 				Directory: "/build",
 				Arguments: []string{"clang++", "-o", "out.o", "in.cc"},
 			},
 			expected: "/build/out.o",
 		},
 		{
 			cmd: CompileCommand{
 				Directory: "/build",
 				Command:   "clang++ -o /abs/out.o in.cc",
 			},
 			expected: "/abs/out.o",
 		},
 	}

 	for _, test := range tests {
 		result, err := ExtractOutput(test.cmd)
 		if err != nil {
 			t.Errorf("ExtractOutput failed: %v", err)
 		}
 		if result != test.expected {
 			t.Errorf("ExtractOutput = %q; want %q", result, test.expected)
 		}
 	}
 }

 func TestPopulateTargets(t *testing.T) {
 	// Create a temporary business logic context.
 	tmpDir, err := os.MkdirTemp("", "ide-query-test")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer os.RemoveAll(tmpDir)

 	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
 	buildDir := filepath.Join(fuchsiaDir, "out/default")
 	os.MkdirAll(buildDir, 0755)

 	sourceFile := filepath.Join(fuchsiaDir, "src/main.cc")
 	os.MkdirAll(filepath.Dir(sourceFile), 0755)
 	os.WriteFile(sourceFile, []byte("void main() {}"), 0644)

 	// Create a mock compile_commands.json
 	compDb := []CompileCommand{
 		{
 			Directory: buildDir,
 			File:      "../../src/main.cc",
 			Arguments: []string{"clang++", "-o", "obj/main.o", "-c", "../../src/main.cc"},
 		},
 	}
 	dbContent, _ := json.Marshal(compDb)
 	os.WriteFile(filepath.Join(buildDir, "compile_commands.json"), dbContent, 0644)

 	// Mock the Build API resolver.
 	oldResolve := resolveNinjaPath
 	defer func() { resolveNinjaPath = oldResolve }()
 	resolveNinjaPath = func(ctx *WorkspaceContext, ninjaPath string) (string, error) {
 		if ninjaPath == "obj/main.o" {
 			return "//src:main_target", nil
 		}
 		return "", nil
 	}

 	ctx := &WorkspaceContext{
 		FuchsiaDir: fuchsiaDir,
 		BuildDir:   buildDir,
 		Files: []FileEntry{
 			{
 				AbsPath: sourceFile,
 				Status:  StatusFound,
 			},
 		},
 	}

 	if err := ctx.PopulateTargets(); err != nil {
 		t.Fatalf("PopulateTargets failed: %v", err)
 	}

 	if len(ctx.Files[0].BuildTargets) != 1 || ctx.Files[0].BuildTargets[0] != "//src:main_target" {
 		t.Errorf("expected //src:main_target, got %v", ctx.Files[0].BuildTargets)
 	}
 }

 func TestPopulateTargets_NestedHeader(t *testing.T) {
 	tmpDir, err := os.MkdirTemp("", "ide-query-test-nested")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer os.RemoveAll(tmpDir)

 	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
 	buildDir := filepath.Join(fuchsiaDir, "out/default")
 	os.MkdirAll(buildDir, 0755)

 	sourceFile := filepath.Join(fuchsiaDir, "zircon/kernel/lib/arch/x86/standard-segments.cc")
 	headerFile := filepath.Join(fuchsiaDir, "zircon/kernel/lib/arch/x86/include/lib/arch/x86/standard-segments.h")
 	os.MkdirAll(filepath.Dir(sourceFile), 0755)
 	os.MkdirAll(filepath.Dir(headerFile), 0755)
 	os.WriteFile(sourceFile, []byte("void f() {}"), 0644)
 	os.WriteFile(headerFile, []byte("void f();"), 0644)

 	compDb := []CompileCommand{
 		{
 			Directory: buildDir,
 			File:      "../../zircon/kernel/lib/arch/x86/standard-segments.cc",
 			Arguments: []string{"clang++", "-o", "obj/zircon/kernel/lib/arch/x86/standard-segments.o", "-c", "../../zircon/kernel/lib/arch/x86/standard-segments.cc"},
 		},
 	}
 	dbContent, _ := json.Marshal(compDb)
 	os.WriteFile(filepath.Join(buildDir, "compile_commands.json"), dbContent, 0644)

 	oldResolve := resolveNinjaPath
 	defer func() { resolveNinjaPath = oldResolve }()
 	resolveNinjaPath = func(ctx *WorkspaceContext, ninjaPath string) (string, error) {
 		if ninjaPath == "obj/zircon/kernel/lib/arch/x86/standard-segments.o" {
 			return "//zircon/kernel/lib/arch/x86:x86", nil
 		}
 		return "", nil
 	}

 	ctx := &WorkspaceContext{
 		FuchsiaDir: fuchsiaDir,
 		BuildDir:   buildDir,
 		Files: []FileEntry{
 			{
 				AbsPath: headerFile,
 				Status:  StatusFound,
 			},
 		},
 	}

 	if err := ctx.PopulateTargets(); err != nil {
 		t.Fatalf("PopulateTargets failed: %v", err)
 	}

 	if len(ctx.Files[0].BuildTargets) != 1 || ctx.Files[0].BuildTargets[0] != "//zircon/kernel/lib/arch/x86:x86" {
 		t.Errorf("expected //zircon/kernel/lib/arch/x86:x86, got %v", ctx.Files[0].BuildTargets)
 	}
 }
 func TestVerifyBuild_NoArgsGn(t *testing.T) {
 	tmpDir := t.TempDir()
 	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
 	buildDir := filepath.Join(fuchsiaDir, "out/default")
 	os.MkdirAll(buildDir, 0755)

 	ctx := &WorkspaceContext{
 		FuchsiaDir: fuchsiaDir,
 		BuildDir:   buildDir,
 		Files: []FileEntry{
 			{AbsPath: filepath.Join(fuchsiaDir, "src/main.cc"), Status: StatusFound},
 		},
 	}

 	if err := ctx.VerifyBuild(); err != nil {
 		t.Fatalf("VerifyBuild failed: %v", err)
 	}

 	if !strings.Contains(ctx.Files[0].AnalysisError, "args.gn missing") {
 		t.Errorf("expected AnalysisError about missing args.gn, got %q", ctx.Files[0].AnalysisError)
 	}
 }

 func TestVerifyBuild_Success(t *testing.T) {
 	tmpDir := t.TempDir()
 	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
 	buildDir := filepath.Join(fuchsiaDir, "out/default")
 	os.MkdirAll(buildDir, 0755)
 	os.WriteFile(filepath.Join(buildDir, "args.gn"), []byte("foo=bar"), 0644)

 	// Mock runFx
 	oldRunFx := runFx
 	defer func() { runFx = oldRunFx }()
 	runFxCalled := false
 	runFx = func(ctx *WorkspaceContext, dir string, args ...string) error {
 		if args[0] == "build" {
 			runFxCalled = true
 		}
 		return nil
 	}

 	ctx := &WorkspaceContext{
 		FuchsiaDir: fuchsiaDir,
 		BuildDir:   buildDir,
 		Files: []FileEntry{
 			{
 				AbsPath:      filepath.Join(fuchsiaDir, "src/main.cc"),
 				Status:       StatusFound,
 				BuildTargets: []string{"//src:main"},
 			},
 		},
 	}

 	if err := ctx.VerifyBuild(); err != nil {
 		t.Fatalf("VerifyBuild failed: %v", err)
 	}

 	if !runFxCalled {
 		t.Error("expected runFx to be called for build")
 	}

 	if ctx.Files[0].AnalysisResult == nil || ctx.Files[0].AnalysisResult.Status != AnalysisStatusOk {
 		t.Errorf("expected AnalysisStatusOk, got %+v", ctx.Files[0].AnalysisResult)
 	}
 }

 func TestVerifyBuild_Failure(t *testing.T) {
 	tmpDir := t.TempDir()
 	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
 	buildDir := filepath.Join(fuchsiaDir, "out/default")
 	os.MkdirAll(buildDir, 0755)
 	os.WriteFile(filepath.Join(buildDir, "args.gn"), []byte("foo=bar"), 0644)

 	// Mock runFx to fail on build
 	oldRunFx := runFx
 	defer func() { runFx = oldRunFx }()
 	runFx = func(ctx *WorkspaceContext, dir string, args ...string) error {
 		if args[0] == "build" {
 			return fmt.Errorf("build failed")
 		}
 		return nil
 	}

 	ctx := &WorkspaceContext{
 		FuchsiaDir: fuchsiaDir,
 		BuildDir:   buildDir,
 		Files: []FileEntry{
 			{
 				AbsPath:      filepath.Join(fuchsiaDir, "src/main.cc"),
 				Status:       StatusFound,
 				BuildTargets: []string{"//src:main"},
 			},
 		},
 	}

 	if err := ctx.VerifyBuild(); err != nil {
 		t.Fatalf("VerifyBuild failed: %v", err)
 	}

 	if ctx.Files[0].AnalysisResult == nil || ctx.Files[0].AnalysisResult.Status != AnalysisStatusBuildFailed {
 		t.Errorf("expected AnalysisStatusBuildFailed, got %+v", ctx.Files[0].AnalysisResult)
 	}
 	if ctx.Files[0].AnalysisResult.Message != "File failed to build." {
 		t.Errorf("expected 'File failed to build.', got %q", ctx.Files[0].AnalysisResult.Message)
 	}
 }

 func TestVerifyBuild_GenFailure(t *testing.T) {
 	tmpDir := t.TempDir()
 	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
 	buildDir := filepath.Join(fuchsiaDir, "out/default")
 	os.MkdirAll(buildDir, 0755)
 	os.WriteFile(filepath.Join(buildDir, "args.gn"), []byte("foo=bar"), 0644)

 	// Mock runFx to fail on gen
 	oldRunFx := runFx
 	defer func() { runFx = oldRunFx }()
 	runFx = func(ctx *WorkspaceContext, dir string, args ...string) error {
 		if args[0] == "gen" {
 			return fmt.Errorf("gen failed")
 		}
 		return nil
 	}

 	ctx := &WorkspaceContext{
 		FuchsiaDir: fuchsiaDir,
 		BuildDir:   buildDir,
 		Files: []FileEntry{
 			{
 				AbsPath: filepath.Join(fuchsiaDir, "src/main.cc"),
 				Status:  StatusFound,
 			},
 		},
 	}

 	if err := ctx.VerifyBuild(); err != nil {
 		t.Fatalf("VerifyBuild failed: %v", err)
 	}

 	if !strings.Contains(ctx.Files[0].AnalysisError, "fx gen failed") {
 		t.Errorf("expected AnalysisError about fx gen failure, got %q", ctx.Files[0].AnalysisError)
 	}
 }

 func TestVerifyBuild_SyncFailure(t *testing.T) {
 	tmpDir := t.TempDir()
 	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
 	buildDir := filepath.Join(fuchsiaDir, "out/default")
 	os.MkdirAll(buildDir, 0755)
 	os.WriteFile(filepath.Join(buildDir, "args.gn"), []byte("foo=bar"), 0644)

 	// Create a file where ide-analysis/args.gn should go, and make it a directory to cause WriteFile to fail.
 	ideAnalysisDir := filepath.Join(fuchsiaDir, "out", ".ide-analysis")
 	os.MkdirAll(filepath.Join(ideAnalysisDir, "args.gn"), 0755)

 	ctx := &WorkspaceContext{
 		FuchsiaDir: fuchsiaDir,
 		BuildDir:   buildDir,
 		Files: []FileEntry{
 			{
 				AbsPath: filepath.Join(fuchsiaDir, "src/main.cc"),
 				Status:  StatusFound,
 			},
 		},
 	}

 	if err := ctx.VerifyBuild(); err != nil {
 		t.Fatalf("VerifyBuild failed: %v", err)
 	}

 	if !strings.Contains(ctx.Files[0].AnalysisError, "failed to sync args.gn") {
 		t.Errorf("expected AnalysisError about sync failure, got %q", ctx.Files[0].AnalysisError)
 	}
 }

 func TestPopulateTargets_DeterministicNeighbor(t *testing.T) {
 	tmpDir, err := os.MkdirTemp("", "ide-query-test-determinism")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer os.RemoveAll(tmpDir)

 	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
 	buildDir := filepath.Join(fuchsiaDir, "out/default")
 	os.MkdirAll(buildDir, 0755)

 	fileA := filepath.Join(fuchsiaDir, "src/a.cc")
 	fileB := filepath.Join(fuchsiaDir, "src/b.cc")
 	headerFile := filepath.Join(fuchsiaDir, "src/header.h")
 	os.MkdirAll(filepath.Dir(fileA), 0755)
 	os.WriteFile(fileA, []byte(""), 0644)
 	os.WriteFile(fileB, []byte(""), 0644)
 	os.WriteFile(headerFile, []byte(""), 0644)

 	// In the compdb, A comes before B.
 	// dirToCmd["src"] should be A's command.
 	compDb := []CompileCommand{
 		{
 			Directory: buildDir,
 			File:      "../../src/a.cc",
 			Arguments: []string{"clang++", "-o", "obj/a.o", "-c", "../../src/a.cc"},
 		},
 		{
 			Directory: buildDir,
 			File:      "../../src/b.cc",
 			Arguments: []string{"clang++", "-o", "obj/b.o", "-c", "../../src/b.cc"},
 		},
 	}
 	dbContent, _ := json.Marshal(compDb)
 	os.WriteFile(filepath.Join(buildDir, "compile_commands.json"), dbContent, 0644)

 	oldResolve := resolveNinjaPath
 	defer func() { resolveNinjaPath = oldResolve }()
 	resolveNinjaPath = func(ctx *WorkspaceContext, ninjaPath string) (string, error) {
 		if ninjaPath == "obj/a.o" {
 			return "//src:a", nil
 		}
 		if ninjaPath == "obj/b.o" {
 			return "//src:b", nil
 		}
 		return "", nil
 	}

 	ctx := &WorkspaceContext{
 		FuchsiaDir: fuchsiaDir,
 		BuildDir:   buildDir,
 		Files: []FileEntry{
 			{
 				AbsPath: headerFile,
 				Status:  StatusFound,
 			},
 		},
 	}

 	if err := ctx.PopulateTargets(); err != nil {
 		t.Fatalf("PopulateTargets failed: %v", err)
 	}

 	// Should favor the first one in the list (//src:a) because we only
 	// set the dirToCmd map if it's not already present.
 	if len(ctx.Files[0].BuildTargets) != 1 || ctx.Files[0].BuildTargets[0] != "//src:a" {
 		t.Errorf("expected //src:a, got %v", ctx.Files[0].BuildTargets)
 	}
 }

 func TestPopulateTargets_MultipleTargets(t *testing.T) {
 	tmpDir, err := os.MkdirTemp("", "ide-query-test-multi")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer os.RemoveAll(tmpDir)

 	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
 	buildDir := filepath.Join(fuchsiaDir, "out/default")
 	os.MkdirAll(buildDir, 0755)

 	sourceFile := filepath.Join(fuchsiaDir, "src/main.cc")
 	os.MkdirAll(filepath.Dir(sourceFile), 0755)
 	os.WriteFile(sourceFile, []byte(""), 0644)

 	// Create a mock compile_commands.json with TWO entries for the same file.
 	compDb := []CompileCommand{
 		{
 			Directory: buildDir,
 			File:      "../../src/main.cc",
 			Arguments: []string{"clang++", "-o", "obj/foo.o", "-c", "../../src/main.cc"},
 		},
 		{
 			Directory: buildDir,
 			File:      "../../src/main.cc",
 			Arguments: []string{"clang++", "-o", "obj/bar.o", "-c", "../../src/main.cc"},
 		},
 	}
 	dbContent, _ := json.Marshal(compDb)
 	os.WriteFile(filepath.Join(buildDir, "compile_commands.json"), dbContent, 0644)

 	oldResolve := resolveNinjaPath
 	defer func() { resolveNinjaPath = oldResolve }()
 	resolveNinjaPath = func(ctx *WorkspaceContext, ninjaPath string) (string, error) {
 		if ninjaPath == "obj/foo.o" {
 			return "//src:foo", nil
 		}
 		if ninjaPath == "obj/bar.o" {
 			return "//src:bar", nil
 		}
 		return "", nil
 	}

 	ctx := &WorkspaceContext{
 		FuchsiaDir: fuchsiaDir,
 		BuildDir:   buildDir,
 		Files: []FileEntry{
 			{
 				AbsPath: sourceFile,
 				Status:  StatusFound,
 			},
 		},
 	}

 	if err := ctx.PopulateTargets(); err != nil {
 		t.Fatalf("PopulateTargets failed: %v", err)
 	}

 	// Should pick //src:bar because it's alphabetically before //src:foo
 	if len(ctx.Files[0].BuildTargets) != 1 || ctx.Files[0].BuildTargets[0] != "//src:bar" {
 		t.Errorf("expected //src:bar, got %v", ctx.Files[0].BuildTargets)
 	}
 }
	// Copyright 2026 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package main

	import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"testing"
	)

	func TestSplitCommand(t *testing.T) {
	tests := []struct {
	cmd string
	expected []string
	}{
	{
	cmd: "clang++ -o obj/file.o -c file.cc",
	expected: []string{"clang++", "-o", "obj/file.o", "-c", "file.cc"},
	},
	{
	cmd: `clang++ "-DQUOTED_ARG" -o "obj/path with spaces.o"`,
	expected: []string{"clang++", "-DQUOTED_ARG", "-o", "obj/path with spaces.o"},
	},
	{
	cmd: `clang++ 'single quoted' -DFOO=\"bar\"`,
	expected: []string{"clang++", "single quoted", "-DFOO=\"bar\""},
	},
	{
	cmd: "arg1\\ with\\ space arg2",
	expected: []string{"arg1 with space", "arg2"},
	},
	}

	for _, test := range tests {
	result := splitCommand(test.cmd)
	if !reflect.DeepEqual(result, test.expected) {
	t.Errorf("splitCommand(%q) = %v; want %v", test.cmd, result, test.expected)
	}
	}
	}

	func TestExtractOutput(t *testing.T) {
	tests := []struct {
	cmd CompileCommand
	expected string
	}{
	{
	cmd: CompileCommand{
	Directory: "/build",
	Arguments: []string{"clang++", "-o", "out.o", "in.cc"},
	},
	expected: "/build/out.o",
	},
	{
	cmd: CompileCommand{
	Directory: "/build",
	Command: "clang++ -o /abs/out.o in.cc",
	},
	expected: "/abs/out.o",
	},
	}

	for _, test := range tests {
	result, err := ExtractOutput(test.cmd)
	if err != nil {
	t.Errorf("ExtractOutput failed: %v", err)
	}
	if result != test.expected {
	t.Errorf("ExtractOutput = %q; want %q", result, test.expected)
	}
	}
	}

	func TestPopulateTargets(t *testing.T) {
	// Create a temporary business logic context.
	tmpDir, err := os.MkdirTemp("", "ide-query-test")
	if err != nil {
	t.Fatal(err)
	}
	defer os.RemoveAll(tmpDir)

	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
	buildDir := filepath.Join(fuchsiaDir, "out/default")
	os.MkdirAll(buildDir, 0755)

	sourceFile := filepath.Join(fuchsiaDir, "src/main.cc")
	os.MkdirAll(filepath.Dir(sourceFile), 0755)
	os.WriteFile(sourceFile, []byte("void main() {}"), 0644)

	// Create a mock compile_commands.json
	compDb := []CompileCommand{
	{
	Directory: buildDir,
	File: "../../src/main.cc",
	Arguments: []string{"clang++", "-o", "obj/main.o", "-c", "../../src/main.cc"},
	},
	}
	dbContent, _ := json.Marshal(compDb)
	os.WriteFile(filepath.Join(buildDir, "compile_commands.json"), dbContent, 0644)

	// Mock the Build API resolver.
	oldResolve := resolveNinjaPath
	defer func() { resolveNinjaPath = oldResolve }()
	resolveNinjaPath = func(ctx *WorkspaceContext, ninjaPath string) (string, error) {
	if ninjaPath == "obj/main.o" {
	return "//src:main_target", nil
	}
	return "", nil
	}

	ctx := &WorkspaceContext{
	FuchsiaDir: fuchsiaDir,
	BuildDir: buildDir,
	Files: []FileEntry{
	{
	AbsPath: sourceFile,
	Status: StatusFound,
	},
	},
	}

	if err := ctx.PopulateTargets(); err != nil {
	t.Fatalf("PopulateTargets failed: %v", err)
	}

	if len(ctx.Files[0].BuildTargets) != 1 \|\| ctx.Files[0].BuildTargets[0] != "//src:main_target" {
	t.Errorf("expected //src:main_target, got %v", ctx.Files[0].BuildTargets)
	}
	}

	func TestPopulateTargets_NestedHeader(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "ide-query-test-nested")
	if err != nil {
	t.Fatal(err)
	}
	defer os.RemoveAll(tmpDir)

	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
	buildDir := filepath.Join(fuchsiaDir, "out/default")
	os.MkdirAll(buildDir, 0755)

	sourceFile := filepath.Join(fuchsiaDir, "zircon/kernel/lib/arch/x86/standard-segments.cc")
	headerFile := filepath.Join(fuchsiaDir, "zircon/kernel/lib/arch/x86/include/lib/arch/x86/standard-segments.h")
	os.MkdirAll(filepath.Dir(sourceFile), 0755)
	os.MkdirAll(filepath.Dir(headerFile), 0755)
	os.WriteFile(sourceFile, []byte("void f() {}"), 0644)
	os.WriteFile(headerFile, []byte("void f();"), 0644)

	compDb := []CompileCommand{
	{
	Directory: buildDir,
	File: "../../zircon/kernel/lib/arch/x86/standard-segments.cc",
	Arguments: []string{"clang++", "-o", "obj/zircon/kernel/lib/arch/x86/standard-segments.o", "-c", "../../zircon/kernel/lib/arch/x86/standard-segments.cc"},
	},
	}
	dbContent, _ := json.Marshal(compDb)
	os.WriteFile(filepath.Join(buildDir, "compile_commands.json"), dbContent, 0644)

	oldResolve := resolveNinjaPath
	defer func() { resolveNinjaPath = oldResolve }()
	resolveNinjaPath = func(ctx *WorkspaceContext, ninjaPath string) (string, error) {
	if ninjaPath == "obj/zircon/kernel/lib/arch/x86/standard-segments.o" {
	return "//zircon/kernel/lib/arch/x86:x86", nil
	}
	return "", nil
	}

	ctx := &WorkspaceContext{
	FuchsiaDir: fuchsiaDir,
	BuildDir: buildDir,
	Files: []FileEntry{
	{
	AbsPath: headerFile,
	Status: StatusFound,
	},
	},
	}

	if err := ctx.PopulateTargets(); err != nil {
	t.Fatalf("PopulateTargets failed: %v", err)
	}

	if len(ctx.Files[0].BuildTargets) != 1 \|\| ctx.Files[0].BuildTargets[0] != "//zircon/kernel/lib/arch/x86:x86" {
	t.Errorf("expected //zircon/kernel/lib/arch/x86:x86, got %v", ctx.Files[0].BuildTargets)
	}
	}
	func TestVerifyBuild_NoArgsGn(t *testing.T) {
	tmpDir := t.TempDir()
	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
	buildDir := filepath.Join(fuchsiaDir, "out/default")
	os.MkdirAll(buildDir, 0755)

	ctx := &WorkspaceContext{
	FuchsiaDir: fuchsiaDir,
	BuildDir: buildDir,
	Files: []FileEntry{
	{AbsPath: filepath.Join(fuchsiaDir, "src/main.cc"), Status: StatusFound},
	},
	}

	if err := ctx.VerifyBuild(); err != nil {
	t.Fatalf("VerifyBuild failed: %v", err)
	}

	if !strings.Contains(ctx.Files[0].AnalysisError, "args.gn missing") {
	t.Errorf("expected AnalysisError about missing args.gn, got %q", ctx.Files[0].AnalysisError)
	}
	}

	func TestVerifyBuild_Success(t *testing.T) {
	tmpDir := t.TempDir()
	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
	buildDir := filepath.Join(fuchsiaDir, "out/default")
	os.MkdirAll(buildDir, 0755)
	os.WriteFile(filepath.Join(buildDir, "args.gn"), []byte("foo=bar"), 0644)

	// Mock runFx
	oldRunFx := runFx
	defer func() { runFx = oldRunFx }()
	runFxCalled := false
	runFx = func(ctx *WorkspaceContext, dir string, args ...string) error {
	if args[0] == "build" {
	runFxCalled = true
	}
	return nil
	}

	ctx := &WorkspaceContext{
	FuchsiaDir: fuchsiaDir,
	BuildDir: buildDir,
	Files: []FileEntry{
	{
	AbsPath: filepath.Join(fuchsiaDir, "src/main.cc"),
	Status: StatusFound,
	BuildTargets: []string{"//src:main"},
	},
	},
	}

	if err := ctx.VerifyBuild(); err != nil {
	t.Fatalf("VerifyBuild failed: %v", err)
	}

	if !runFxCalled {
	t.Error("expected runFx to be called for build")
	}

	if ctx.Files[0].AnalysisResult == nil \|\| ctx.Files[0].AnalysisResult.Status != AnalysisStatusOk {
	t.Errorf("expected AnalysisStatusOk, got %+v", ctx.Files[0].AnalysisResult)
	}
	}

	func TestVerifyBuild_Failure(t *testing.T) {
	tmpDir := t.TempDir()
	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
	buildDir := filepath.Join(fuchsiaDir, "out/default")
	os.MkdirAll(buildDir, 0755)
	os.WriteFile(filepath.Join(buildDir, "args.gn"), []byte("foo=bar"), 0644)

	// Mock runFx to fail on build
	oldRunFx := runFx
	defer func() { runFx = oldRunFx }()
	runFx = func(ctx *WorkspaceContext, dir string, args ...string) error {
	if args[0] == "build" {
	return fmt.Errorf("build failed")
	}
	return nil
	}

	ctx := &WorkspaceContext{
	FuchsiaDir: fuchsiaDir,
	BuildDir: buildDir,
	Files: []FileEntry{
	{
	AbsPath: filepath.Join(fuchsiaDir, "src/main.cc"),
	Status: StatusFound,
	BuildTargets: []string{"//src:main"},
	},
	},
	}

	if err := ctx.VerifyBuild(); err != nil {
	t.Fatalf("VerifyBuild failed: %v", err)
	}

	if ctx.Files[0].AnalysisResult == nil \|\| ctx.Files[0].AnalysisResult.Status != AnalysisStatusBuildFailed {
	t.Errorf("expected AnalysisStatusBuildFailed, got %+v", ctx.Files[0].AnalysisResult)
	}
	if ctx.Files[0].AnalysisResult.Message != "File failed to build." {
	t.Errorf("expected 'File failed to build.', got %q", ctx.Files[0].AnalysisResult.Message)
	}
	}

	func TestVerifyBuild_GenFailure(t *testing.T) {
	tmpDir := t.TempDir()
	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
	buildDir := filepath.Join(fuchsiaDir, "out/default")
	os.MkdirAll(buildDir, 0755)
	os.WriteFile(filepath.Join(buildDir, "args.gn"), []byte("foo=bar"), 0644)

	// Mock runFx to fail on gen
	oldRunFx := runFx
	defer func() { runFx = oldRunFx }()
	runFx = func(ctx *WorkspaceContext, dir string, args ...string) error {
	if args[0] == "gen" {
	return fmt.Errorf("gen failed")
	}
	return nil
	}

	ctx := &WorkspaceContext{
	FuchsiaDir: fuchsiaDir,
	BuildDir: buildDir,
	Files: []FileEntry{
	{
	AbsPath: filepath.Join(fuchsiaDir, "src/main.cc"),
	Status: StatusFound,
	},
	},
	}

	if err := ctx.VerifyBuild(); err != nil {
	t.Fatalf("VerifyBuild failed: %v", err)
	}

	if !strings.Contains(ctx.Files[0].AnalysisError, "fx gen failed") {
	t.Errorf("expected AnalysisError about fx gen failure, got %q", ctx.Files[0].AnalysisError)
	}
	}

	func TestVerifyBuild_SyncFailure(t *testing.T) {
	tmpDir := t.TempDir()
	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
	buildDir := filepath.Join(fuchsiaDir, "out/default")
	os.MkdirAll(buildDir, 0755)
	os.WriteFile(filepath.Join(buildDir, "args.gn"), []byte("foo=bar"), 0644)

	// Create a file where ide-analysis/args.gn should go, and make it a directory to cause WriteFile to fail.
	ideAnalysisDir := filepath.Join(fuchsiaDir, "out", ".ide-analysis")
	os.MkdirAll(filepath.Join(ideAnalysisDir, "args.gn"), 0755)

	ctx := &WorkspaceContext{
	FuchsiaDir: fuchsiaDir,
	BuildDir: buildDir,
	Files: []FileEntry{
	{
	AbsPath: filepath.Join(fuchsiaDir, "src/main.cc"),
	Status: StatusFound,
	},
	},
	}

	if err := ctx.VerifyBuild(); err != nil {
	t.Fatalf("VerifyBuild failed: %v", err)
	}

	if !strings.Contains(ctx.Files[0].AnalysisError, "failed to sync args.gn") {
	t.Errorf("expected AnalysisError about sync failure, got %q", ctx.Files[0].AnalysisError)
	}
	}

	func TestPopulateTargets_DeterministicNeighbor(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "ide-query-test-determinism")
	if err != nil {
	t.Fatal(err)
	}
	defer os.RemoveAll(tmpDir)

	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
	buildDir := filepath.Join(fuchsiaDir, "out/default")
	os.MkdirAll(buildDir, 0755)

	fileA := filepath.Join(fuchsiaDir, "src/a.cc")
	fileB := filepath.Join(fuchsiaDir, "src/b.cc")
	headerFile := filepath.Join(fuchsiaDir, "src/header.h")
	os.MkdirAll(filepath.Dir(fileA), 0755)
	os.WriteFile(fileA, []byte(""), 0644)
	os.WriteFile(fileB, []byte(""), 0644)
	os.WriteFile(headerFile, []byte(""), 0644)

	// In the compdb, A comes before B.
	// dirToCmd["src"] should be A's command.
	compDb := []CompileCommand{
	{
	Directory: buildDir,
	File: "../../src/a.cc",
	Arguments: []string{"clang++", "-o", "obj/a.o", "-c", "../../src/a.cc"},
	},
	{
	Directory: buildDir,
	File: "../../src/b.cc",
	Arguments: []string{"clang++", "-o", "obj/b.o", "-c", "../../src/b.cc"},
	},
	}
	dbContent, _ := json.Marshal(compDb)
	os.WriteFile(filepath.Join(buildDir, "compile_commands.json"), dbContent, 0644)

	oldResolve := resolveNinjaPath
	defer func() { resolveNinjaPath = oldResolve }()
	resolveNinjaPath = func(ctx *WorkspaceContext, ninjaPath string) (string, error) {
	if ninjaPath == "obj/a.o" {
	return "//src:a", nil
	}
	if ninjaPath == "obj/b.o" {
	return "//src:b", nil
	}
	return "", nil
	}

	ctx := &WorkspaceContext{
	FuchsiaDir: fuchsiaDir,
	BuildDir: buildDir,
	Files: []FileEntry{
	{
	AbsPath: headerFile,
	Status: StatusFound,
	},
	},
	}

	if err := ctx.PopulateTargets(); err != nil {
	t.Fatalf("PopulateTargets failed: %v", err)
	}

	// Should favor the first one in the list (//src:a) because we only
	// set the dirToCmd map if it's not already present.
	if len(ctx.Files[0].BuildTargets) != 1 \|\| ctx.Files[0].BuildTargets[0] != "//src:a" {
	t.Errorf("expected //src:a, got %v", ctx.Files[0].BuildTargets)
	}
	}

	func TestPopulateTargets_MultipleTargets(t *testing.T) {
	tmpDir, err := os.MkdirTemp("", "ide-query-test-multi")
	if err != nil {
	t.Fatal(err)
	}
	defer os.RemoveAll(tmpDir)

	fuchsiaDir := filepath.Join(tmpDir, "fuchsia")
	buildDir := filepath.Join(fuchsiaDir, "out/default")
	os.MkdirAll(buildDir, 0755)

	sourceFile := filepath.Join(fuchsiaDir, "src/main.cc")
	os.MkdirAll(filepath.Dir(sourceFile), 0755)
	os.WriteFile(sourceFile, []byte(""), 0644)

	// Create a mock compile_commands.json with TWO entries for the same file.
	compDb := []CompileCommand{
	{
	Directory: buildDir,
	File: "../../src/main.cc",
	Arguments: []string{"clang++", "-o", "obj/foo.o", "-c", "../../src/main.cc"},
	},
	{
	Directory: buildDir,
	File: "../../src/main.cc",
	Arguments: []string{"clang++", "-o", "obj/bar.o", "-c", "../../src/main.cc"},
	},
	}
	dbContent, _ := json.Marshal(compDb)
	os.WriteFile(filepath.Join(buildDir, "compile_commands.json"), dbContent, 0644)

	oldResolve := resolveNinjaPath
	defer func() { resolveNinjaPath = oldResolve }()
	resolveNinjaPath = func(ctx *WorkspaceContext, ninjaPath string) (string, error) {
	if ninjaPath == "obj/foo.o" {
	return "//src:foo", nil
	}
	if ninjaPath == "obj/bar.o" {
	return "//src:bar", nil
	}
	return "", nil
	}

	ctx := &WorkspaceContext{
	FuchsiaDir: fuchsiaDir,
	BuildDir: buildDir,
	Files: []FileEntry{
	{
	AbsPath: sourceFile,
	Status: StatusFound,
	},
	},
	}

	if err := ctx.PopulateTargets(); err != nil {
	t.Fatalf("PopulateTargets failed: %v", err)
	}

	// Should pick //src:bar because it's alphabetically before //src:foo
	if len(ctx.Files[0].BuildTargets) != 1 \|\| ctx.Files[0].BuildTargets[0] != "//src:bar" {
	t.Errorf("expected //src:bar, got %v", ctx.Files[0].BuildTargets)
	}
	}