Add the integration IO test as an example

This IMHO is superior to what we're doing today.

Skip the test if we do not have a u-root command

Signed-off-by: Ronald G Minnich <[email protected]>

Author: rminnich

initramfs/initramfs.go

@@ -54,10 +54,10 @@ type Image struct {
 }
 
 var images = map[string]Image{
-	"linux_amd64":   Image{Kernel: kernel_linux_amd64, InitRAMFS: linux_amd64, Cmd: []string{"qemu-system-x86_64", "-m", "1G"}},
-	"linux_arm64":   Image{Kernel: kernel_linux_arm64, InitRAMFS: linux_arm64, Cmd: []string{"qemu-system-aarch64", "-machine", "virt", "-cpu", "max", "-m", "1G"}},
-	"linux_arm":     Image{Kernel: kernel_linux_arm, InitRAMFS: linux_arm, Cmd: []string{"qemu-system-arm", "-M", "virt,highmem=off"}},
-	"linux_riscv64": Image{Kernel: kernel_linux_riscv64, InitRAMFS: linux_riscv64, Cmd: []string{"qemu-system-riscv64", "-M", "virt", "-cpu", "rv64", "-m", "1G"}},
+	"linux_amd64":   {Kernel: kernel_linux_amd64, InitRAMFS: linux_amd64, Cmd: []string{"qemu-system-x86_64", "-m", "1G"}},
+	"linux_arm64":   {Kernel: kernel_linux_arm64, InitRAMFS: linux_arm64, Cmd: []string{"qemu-system-aarch64", "-machine", "virt", "-cpu", "max", "-m", "1G"}},
+	"linux_arm":     {Kernel: kernel_linux_arm, InitRAMFS: linux_arm, Cmd: []string{"qemu-system-arm", "-M", "virt,highmem=off"}},
+	"linux_riscv64": {Kernel: kernel_linux_riscv64, InitRAMFS: linux_riscv64, Cmd: []string{"qemu-system-riscv64", "-M", "virt", "-cpu", "rv64", "-m", "1G"}},
 }
 
 func New(kernel, arch string) (*Image, error) {
@@ -171,6 +171,6 @@ func (i *Image) CPUCommand(arg string, args ...string) (*client.Cmd, error) {
 	if err := cpu.Dial(); err != nil {
 		return nil, err
 	}
-	cpu.Env = append(cpu.Env, "PWD=/")
+	cpu.Env = append(cpu.Env, "PATH=/bbin", "PWD=/", "SHELL=/bbin/x")
 	return cpu, nil
 }

initramfs/initramfs_test.go initramfs/initramfs_linux_test.goinitramfs/initramfs_test.go renamed to initramfs/initramfs_linux_test.go

@@ -11,13 +11,16 @@ import (
 	"errors"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/u-root/cpu/client"
 	"github.com/u-root/cpu/initramfs"
 )
 
-func TestCPU(t *testing.T) {
+// TestCPUAMD64 tests both general and specific things. The specific parts are the io and cmos commands.
+// It being cheaper to use a single generated initramfs, we use the full u-root for several tests.
+func TestCPUAMD64(t *testing.T) {
 	d := t.TempDir()
 	i, err := initramfs.New("linux", "amd64")
 	if !errors.Is(err, nil) {
@@ -34,8 +37,9 @@ func TestCPU(t *testing.T) {
 
 	n, err := initramfs.Uroot(d)
 	if err != nil {
-		t.Fatal(err)
+		t.Skipf("skipping this test as we have no uroot command")
 	}
+
 	c, err := i.CommandContext(ctx, d, n)
 	if err != nil {
 		t.Fatalf("starting VM: got %v, want nil", err)
@@ -56,7 +60,8 @@ func TestCPU(t *testing.T) {
 	} {
 		cpu, err := i.CPUCommand(tt.cmd, tt.args...)
 		if err != nil {
-			t.Fatalf("CPUCommand: got %v, want nil", err)
+			t.Errorf("CPUCommand: got %v, want nil", err)
+			continue
 		}
 		client.SetVerbose(t.Logf)
 
@@ -73,4 +78,34 @@ func TestCPU(t *testing.T) {
 	if string(b) != "hi" {
 		t.Fatalf("file b: got %q, want %q", b, "hi")
 	}
+
+	for _, tt := range []struct {
+		args string
+		out  string
+	}{
+		{args: "cw 14 1", out: ""},
+		{args: "cr 14", out: "0x01\n"},
+		{args: "cw 14 0", out: ""},
+		{args: "cr 14", out: "0x00\n"},
+	} {
+		cpu, err := i.CPUCommand("/bbin/io", strings.Split(tt.args, " ")...)
+		if err != nil {
+			t.Fatalf("CPUCommand: got %v, want nil", err)
+		}
+		client.SetVerbose(t.Logf)
+
+		b, err := cpu.CombinedOutput()
+		if err != nil {
+			t.Errorf("io %s: got %v, want nil", tt.args, err)
+		}
+		if string(b) != tt.out {
+			t.Errorf("io %s: got %v, want %v", tt.args, string(b), tt.out)
+		}
+		t.Logf("io %s = %q", tt.args, string(b))
+	}
+
+	// The io integration tests include writing to 3f8. There's no need to do that,
+	// the cmos write tests all that needs testing, as it uses inb and outb,
+	// and uart hardware is fickle. The test above is enough.
+
 }