sysfs: Improve coverage for thermal

- Correct minor typos.
- Improve sysfs-thermal error wrapping.
- No significant functional change.

conn/doc.go

@@ -55,12 +55,12 @@
 //
 // Most connection-type specific subpackages include subpackages:
 //
-// - XXXreg: registry as that is populated by the host drivers and that can be
+// → XXXreg: registry as that is populated by the host drivers and that can be
 // leveraged by applications.
 //
-// - XXXtest: fake implementation that can be leveraged when writting device
+// → XXXtest: fake implementation that can be leveraged when writing device
 // driver unit test.
 //
-// - XXXsmoketest: smoke test that tests against real hardware to ensure the
+// → XXXsmoketest: smoke test that tests against real hardware to ensure the
 // whole stack work correctly, including the OS supplied drivers.
 package conn

devices/bmxx80/bmp180.go

@@ -15,7 +15,7 @@ import (
 //
 // It must be called with d.mu lock held.
 func (d *Dev) sense180(env *devices.Environment) error {
-	// Request temperature convertion and read measurement.
+	// Request temperature conversion and read measurement.
 	if err := d.writeCommands([]byte{0xF4, 0x20 | 0x0E}); err != nil {
 		return d.wrap(err)
 	}

host/rpi/rpi.go

@@ -44,7 +44,7 @@ func Present() bool {
 //
 // P1 is also known as J8 on A+, B+, 2 and later.
 var (
-	// Rapsberry Pi A and B, 26 pin header:
+	// Raspberry Pi A and B, 26 pin header:
 	P1_1  pin.Pin    = pin.V3_3       // max 30mA
 	P1_2  pin.Pin    = pin.V5         // (filtered)
 	P1_3  gpio.PinIO = bcm283x.GPIO2  // High, I2C1_SDA

host/sysfs/gpio_test.go

@@ -194,6 +194,12 @@ func TestPin_readInt(t *testing.T) {
 	}
 }
 
+func TestGPIODriver(t *testing.T) {
+	if len((&driverGPIO{}).Prerequisites()) != 0 {
+		t.Fatal("unexpected GPIO prerequisites")
+	}
+}
+
 //
 
 type fakeGPIOFile struct {

host/sysfs/i2c_test.go

@@ -33,7 +33,7 @@ func TestNewI2C(t *testing.T) {
 
 func TestI2C_faked(t *testing.T) {
 	// Create a fake I2C to test methods.
-	bus := I2C{f: ioctlClose(0), busNumber: 24}
+	bus := I2C{f: &ioctlClose{}, busNumber: 24}
 	if s := bus.String(); s != "I2C24" {
 		t.Fatal(s)
 	}

host/sysfs/led_test.go

@@ -76,3 +76,9 @@ func TestLED_not_supported(t *testing.T) {
 		t.Fatal(pull)
 	}
 }
+
+func TestLEDDriver(t *testing.T) {
+	if len((&driverLED{}).Prerequisites()) != 0 {
+		t.Fatal("unexpected LED prerequisites")
+	}
+}

host/sysfs/spi_test.go

@@ -43,7 +43,7 @@ func TestNewSPI(t *testing.T) {
 }
 
 func TestSPI_IO(t *testing.T) {
-	port := SPI{f: ioctlClose(0), busNumber: 24}
+	port := SPI{f: &ioctlClose{}, busNumber: 24}
 	c, err := port.Connect(1, spi.Mode3, 8)
 	if err != nil {
 		t.Fatal(err)
@@ -108,7 +108,7 @@ func TestSPI_IO(t *testing.T) {
 }
 
 func TestSPI_IO_not_initialized(t *testing.T) {
-	port := SPI{f: ioctlClose(0), busNumber: 24}
+	port := SPI{f: &ioctlClose{}, busNumber: 24}
 	if _, err := port.txInternal([]byte{0}, []byte{0}); err == nil {
 		t.Fatal("not initialized")
 	}
@@ -118,7 +118,7 @@ func TestSPI_IO_not_initialized(t *testing.T) {
 }
 
 func TestSPI_pins(t *testing.T) {
-	port := SPI{f: ioctlClose(0), busNumber: 24}
+	port := SPI{f: &ioctlClose{}, busNumber: 24}
 	if p := port.CLK(); p != gpio.INVALID {
 		t.Fatal(p)
 	}
@@ -134,7 +134,7 @@ func TestSPI_pins(t *testing.T) {
 }
 
 func TestSPI_other(t *testing.T) {
-	port := SPI{f: ioctlClose(0), busNumber: 24}
+	port := SPI{f: &ioctlClose{}, busNumber: 24}
 	if s := port.String(); s != "SPI24.0" {
 		t.Fatal(s)
 	}
@@ -151,7 +151,7 @@ func TestSPI_other(t *testing.T) {
 
 func TestSPI_Connect(t *testing.T) {
 	// Create a fake SPI to test methods.
-	port := SPI{f: ioctlClose(0), busNumber: 24}
+	port := SPI{f: &ioctlClose{}, busNumber: 24}
 	if _, err := port.Connect(-1, spi.Mode0, 8); err == nil {
 		t.Fatal("invalid speed")
 	}
@@ -191,6 +191,12 @@ func TestSPIIOCTX(t *testing.T) {
 	}
 }
 
+func TestSPIDriver(t *testing.T) {
+	if len((&driverSPI{}).Prerequisites()) != 0 {
+		t.Fatal("unexpected SPI prerequisites")
+	}
+}
+
 //
 
 func init() {

host/sysfs/sysfs.go

@@ -10,15 +10,19 @@ import (
 	"periph.io/x/periph/host/fs"
 )
 
-var ioctlOpen = func(path string, flag int) (ioctlCloser, error) {
+var ioctlOpen = ioctlOpenDefault
+
+func ioctlOpenDefault(path string, flag int) (ioctlCloser, error) {
 	f, err := fs.Open(path, flag)
 	if err != nil {
 		return nil, err
 	}
 	return f, nil
 }
 
-var fileIOOpen = func(path string, flag int) (fileIO, error) {
+var fileIOOpen = fileIOOpenDefault
+
+func fileIOOpenDefault(path string, flag int) (fileIO, error) {
 	f, err := fs.Open(path, flag)
 	if err != nil {
 		return nil, err

host/sysfs/sysfs_test.go

@@ -4,18 +4,63 @@
 
 package sysfs
 
-import "periph.io/x/periph/host/fs"
+import (
+	"errors"
+	"io"
+
+	"periph.io/x/periph/host/fs"
+)
 
 func init() {
 	fs.Inhibit()
+	reset()
 }
 
-type ioctlClose int
+func reset() {
+	fileIOOpen = fileIOOpenDefault
+	ioctlOpen = ioctlOpenDefault
+	// Soon.
+	//fileIOOpen = fileIOOpenPanic
+	//ioctlOpen = ioctlOpenPanic
+}
 
-func (i ioctlClose) Ioctl(op uint, data uintptr) error {
+func ioctlOpenPanic(path string, flag int) (ioctlCloser, error) {
+	panic("don't forget to override fileIOOpen")
+}
+
+func fileIOOpenPanic(path string, flag int) (fileIO, error) {
+	panic("don't forget to override fileIOOpen")
+}
+
+type ioctlClose struct{}
+
+func (i *ioctlClose) Ioctl(op uint, data uintptr) error {
 	return nil
 }
 
-func (i ioctlClose) Close() error {
+func (i *ioctlClose) Close() error {
 	return nil
 }
+
+type file struct {
+	ioctlClose
+}
+
+func (f *file) Fd() uintptr {
+	return 0xFFFFFFFF
+}
+
+func (f *file) Read(p []byte) (int, error) {
+	return 0, errors.New("not implemented")
+}
+
+func (f *file) Seek(offset int64, whence int) (int64, error) {
+	if offset == 0 && whence == io.SeekStart {
+		return 0, nil
+	}
+	return 0, errors.New("not implemented")
+}
+
+func (f *file) Write(p []byte) (int, error) {
+	return 0, errors.New("not implemented")
+}

host/sysfs/thermal_sensor.go

@@ -16,7 +16,6 @@ import (
 
 	"periph.io/x/periph"
 	"periph.io/x/periph/devices"
-	"periph.io/x/periph/host/fs"
 )
 
 // ThermalSensors is all the sensors discovered on this host via sysfs.
@@ -63,13 +62,13 @@ func (t *ThermalSensor) Type() string {
 	if t.nameType == "" {
 		f, err := fileIOOpen(t.root+"type", os.O_RDONLY)
 		if err != nil {
-			return err.Error()
+			return fmt.Sprintf("sysfs-thermal: %v", err)
 		}
 		defer f.Close()
 		var buf [256]byte
 		n, err := f.Read(buf[:])
 		if err != nil {
-			return err.Error()
+			return fmt.Sprintf("sysfs-thermal: %v", err)
 		}
 		if n < 2 {
 			t.nameType = "<unknown>"
@@ -90,14 +89,14 @@ func (t *ThermalSensor) Sense(env *devices.Environment) error {
 	var buf [24]byte
 	n, err := seekRead(t.f, buf[:])
 	if err != nil {
-		return err
+		return fmt.Errorf("sysfs-thermal: %v", err)
 	}
 	if n < 2 {
 		return errors.New("sysfs-thermal: failed to read temperature")
 	}
 	i, err := strconv.Atoi(string(buf[:n-1]))
 	if err != nil {
-		return err
+		return fmt.Errorf("sysfs-thermal: %v", err)
 	}
 	if i < 100 {
 		i *= 1000
@@ -109,7 +108,7 @@ func (t *ThermalSensor) Sense(env *devices.Environment) error {
 // SenseContinuous implements devices.Environmental.
 func (t *ThermalSensor) SenseContinuous(interval time.Duration) (<-chan devices.Environment, error) {
 	// TODO(maruel): Manually poll in a loop via time.NewTicker.
-	return nil, errors.New("not implemented")
+	return nil, errors.New("sysfs-thermal: not implemented")
 }
 
 //
@@ -120,11 +119,12 @@ func (t *ThermalSensor) open() error {
 	if t.f != nil {
 		return nil
 	}
-	f, err := fs.Open(t.root+"temp", os.O_RDONLY)
-	if err == nil {
-		t.f = f
+	f, err := fileIOOpen(t.root+"temp", os.O_RDONLY)
+	if err != nil {
+		return fmt.Errorf("sysfs-thermal: %v", err)
 	}
-	return err
+	t.f = f
+	return nil
 }
 
 // driverThermalSensor implements periph.Driver.