i2c: increase test coverage

Signed-off-by: deadprogram <ron@hybridgroup.com>

drivers/i2c/adafruit_driver_test.go

@@ -57,6 +57,12 @@ func TestAdafruitMotorHatDriverStartReadError(t *testing.T) {
 	gobottest.Assert(t, d.Start(), errors.New("read error"))
 }
 
+func TestAdafruitMotorHatDriverStartConnectError(t *testing.T) {
+	d, adaptor := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestAdafruitMotorHatDriverHalt(t *testing.T) {
 	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
 

drivers/i2c/blinkm_driver_test.go

@@ -112,6 +112,12 @@ func TestBlinkMDriverStart(t *testing.T) {
 	gobottest.Assert(t, blinkM.Start(), errors.New("write error"))
 }
 
+func TestBlinkMDriverStartConnectError(t *testing.T) {
+	d, adaptor := initTestBlinkDriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestBlinkMDriverHalt(t *testing.T) {
 	blinkM := initTestBlinkMDriver()
 	gobottest.Assert(t, blinkM.Halt(), nil)

drivers/i2c/bme280_driver_test.go

@@ -43,6 +43,12 @@ func TestBME280DriverStart(t *testing.T) {
 	gobottest.Assert(t, bme280.Start(), nil)
 }
 
+func TestBME280StartConnectError(t *testing.T) {
+	d, adaptor := initTestBME280DriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestBME280DriverStartWriteError(t *testing.T) {
 	bme280, adaptor := initTestBME280DriverWithStubbedAdaptor()
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {

drivers/i2c/bmp180_driver_test.go

@@ -44,6 +44,12 @@ func TestBMP180DriverStart(t *testing.T) {
 	gobottest.Assert(t, bmp180.Start(), nil)
 }
 
+func TestBMP180StartConnectError(t *testing.T) {
+	d, adaptor := initTestBMP180DriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestBMP180DriverStartWriteError(t *testing.T) {
 	bmp180, adaptor := initTestBMP180DriverWithStubbedAdaptor()
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {

drivers/i2c/bmp280_driver_test.go

@@ -43,6 +43,12 @@ func TestBMP280DriverStart(t *testing.T) {
 	gobottest.Assert(t, bmp280.Start(), nil)
 }
 
+func TestBMP280StartConnectError(t *testing.T) {
+	d, adaptor := initTestBMP280DriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestBMP280DriverStartWriteError(t *testing.T) {
 	bmp280, adaptor := initTestBMP280DriverWithStubbedAdaptor()
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {

drivers/i2c/drv2605l_driver_test.go

@@ -38,6 +38,12 @@ func TestDRV2605LDriverStart(t *testing.T) {
 	gobottest.Assert(t, d.Start(), nil)
 }
 
+func TestDRV2605LStartConnectError(t *testing.T) {
+	d, adaptor := initTestDriverAndAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestDRVD2605DriverStartWriteError(t *testing.T) {
 	d, a := initTestDriverAndAdaptor()
 	a.i2cWriteImpl = func(b []byte) (int, error) {

drivers/i2c/helpers_test.go

@@ -1,6 +1,7 @@
 package i2c
 
 import (
+	"errors"
 	"fmt"
 	"sync"
 )
@@ -20,11 +21,18 @@ var green = castColor("green")
 var blue = castColor("blue")
 
 type i2cTestAdaptor struct {
-	name         string
-	written      []byte
-	mtx          sync.Mutex
-	i2cReadImpl  func([]byte) (int, error)
-	i2cWriteImpl func([]byte) (int, error)
+	name          string
+	written       []byte
+	mtx           sync.Mutex
+	i2cConnectErr bool
+	i2cReadImpl   func([]byte) (int, error)
+	i2cWriteImpl  func([]byte) (int, error)
+}
+
+func (t *i2cTestAdaptor) Testi2cConnectErr(val bool) {
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+	t.i2cConnectErr = val
 }
 
 func (t *i2cTestAdaptor) Testi2cReadImpl(f func([]byte) (int, error)) {
@@ -152,6 +160,9 @@ func (t *i2cTestAdaptor) WriteBlockData(reg uint8, b []byte) (err error) {
 }
 
 func (t *i2cTestAdaptor) GetConnection( /* address */ int /* bus */, int) (connection Connection, err error) {
+	if t.i2cConnectErr {
+		return nil, errors.New("Invalid i2c connection")
+	}
 	return t, nil
 }
 
@@ -166,6 +177,7 @@ func (t *i2cTestAdaptor) Finalize() (err error) { return }
 
 func newI2cTestAdaptor() *i2cTestAdaptor {
 	return &i2cTestAdaptor{
+		i2cConnectErr: false,
 		i2cReadImpl: func([]byte) (int, error) {
 			return 0, nil
 		},

drivers/i2c/hmc6352_driver_test.go

@@ -48,6 +48,12 @@ func TestHMC6352DriverStart(t *testing.T) {
 	gobottest.Assert(t, err, errors.New("write error"))
 }
 
+func TestHMC6352StartConnectError(t *testing.T) {
+	d, adaptor := initTestHMC6352DriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestHMC6352DriverHalt(t *testing.T) {
 	hmc := initTestHMC6352Driver()
 

drivers/i2c/jhd1313m1_driver_test.go

@@ -57,6 +57,12 @@ func TestJHD1313MDriverStart(t *testing.T) {
 	gobottest.Assert(t, d.Start(), nil)
 }
 
+func TestJHD1313MStartConnectError(t *testing.T) {
+	d, adaptor := initTestJHD1313M1DriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestJHD1313MDriverStartWriteError(t *testing.T) {
 	d, adaptor := initTestJHD1313M1DriverWithStubbedAdaptor()
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {

drivers/i2c/l3gd20h_driver_test.go

@@ -46,6 +46,12 @@ func TestL3GD20HDriverStart(t *testing.T) {
 	gobottest.Assert(t, d.Start(), nil)
 }
 
+func TestL3GD20HStartConnectError(t *testing.T) {
+	d, adaptor := initTestL3GD20HDriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestL3GD20HDriverStartWriteError(t *testing.T) {
 	d, adaptor := initTestL3GD20HDriverWithStubbedAdaptor()
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {

drivers/i2c/lidarlite_driver_test.go

@@ -43,6 +43,12 @@ func TestLIDARLiteDriverStart(t *testing.T) {
 	gobottest.Assert(t, hmc.Start(), nil)
 }
 
+func TestLIDARLiteStartConnectError(t *testing.T) {
+	d, adaptor := initTestLIDARLiteDriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestLIDARLiteDriverHalt(t *testing.T) {
 	hmc := initTestLIDARLiteDriver()
 

drivers/i2c/mcp23017_driver_test.go

@@ -92,6 +92,12 @@ func TestMCP23017DriverStart(t *testing.T) {
 	gobottest.Assert(t, err, errors.New("write error"))
 }
 
+func TestMCP23017StartConnectError(t *testing.T) {
+	d, adaptor := initTestMCP23017DriverWithStubbedAdaptor(0)
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestMCP23017DriverHalt(t *testing.T) {
 	mcp := initTestMCP23017Driver(0)
 	gobottest.Assert(t, mcp.Halt(), nil)

drivers/i2c/mma7660_driver_test.go

@@ -58,6 +58,12 @@ func TestMMA7660DriverStart(t *testing.T) {
 	gobottest.Assert(t, d.Start(), nil)
 }
 
+func TestMMA7660StartConnectError(t *testing.T) {
+	d, adaptor := initTestMMA7660DriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestMMA7660DriverStartWriteError(t *testing.T) {
 	mma, adaptor := initTestMMA7660DriverWithStubbedAdaptor()
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {

drivers/i2c/mpl115a2_driver_test.go

@@ -58,6 +58,12 @@ func TestMPL115A2DriverStart(t *testing.T) {
 	gobottest.Assert(t, mpl.Start(), nil)
 }
 
+func TestMPL115A2StartConnectError(t *testing.T) {
+	d, adaptor := initTestMPL115A2DriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestMPL115A2DriverStartWriteError(t *testing.T) {
 	mpl, adaptor := initTestMPL115A2DriverWithStubbedAdaptor()
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {

drivers/i2c/mpu6050_driver_test.go

@@ -52,6 +52,12 @@ func TestMPU6050DriverStart(t *testing.T) {
 	gobottest.Assert(t, mpu.Start(), nil)
 }
 
+func TestMPU6050StartConnectError(t *testing.T) {
+	d, adaptor := initTestMPU6050DriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestMPU6050DriverStartWriteError(t *testing.T) {
 	mpu, adaptor := initTestMPU6050DriverWithStubbedAdaptor()
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {

drivers/i2c/sht3x_driver_test.go

@@ -38,14 +38,18 @@ func TestNewSHT3xDriver(t *testing.T) {
 
 // Methods
 
-// Test Start
 func TestSHT3xDriverStart(t *testing.T) {
 	sht3x, _ := initTestSHT3xDriverWithStubbedAdaptor()
 
 	gobottest.Assert(t, sht3x.Start(), nil)
 }
 
-// Test Halt
+func TestSHT3xStartConnectError(t *testing.T) {
+	d, adaptor := initTestSHT3xDriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestSHT3xDriverHalt(t *testing.T) {
 	sht3x := initTestSHT3xDriver()
 

drivers/i2c/ssd1306_driver_test.go

@@ -1,6 +1,7 @@
 package i2c
 
 import (
+	"errors"
 	"fmt"
 	"reflect"
 	"strings"
@@ -71,14 +72,18 @@ func TestNewSSD1306Driver(t *testing.T) {
 
 // Methods
 
-// Test Start
 func TestSSD1306DriverStart(t *testing.T) {
 	s, _ := initTestSSD1306DriverWithStubbedAdaptor()
 
 	gobottest.Assert(t, s.Start(), nil)
 }
 
-// Test Halt
+func TestSSD1306StartConnectError(t *testing.T) {
+	d, adaptor := initTestSSD1306DriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestSSD1306DriverHalt(t *testing.T) {
 	s := initTestSSD1306Driver()
 

drivers/i2c/tsl2561_driver_test.go

@@ -34,6 +34,12 @@ func TestTSL2561DriverStart(t *testing.T) {
 	gobottest.Refute(t, d.Connection(), nil)
 }
 
+func TestTSL2561StartConnectError(t *testing.T) {
+	d, adaptor := initTestTSL2561Driver()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestTSL2561DriverStartError(t *testing.T) {
 	d, adaptor := initTestTSL2561Driver()
 	adaptor.i2cWriteImpl = func([]byte) (int, error) {

drivers/i2c/wiichuck_driver_test.go

@@ -1,6 +1,7 @@
 package i2c
 
 import (
+	"errors"
 	"strings"
 	"testing"
 	"time"
@@ -75,6 +76,12 @@ func TestWiichuckDriverStart(t *testing.T) {
 
 }
 
+func TestWiichuckStartConnectError(t *testing.T) {
+	d, adaptor := initTestWiichuckDriverWithStubbedAdaptor()
+	adaptor.Testi2cConnectErr(true)
+	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
+}
+
 func TestWiichuckDriverHalt(t *testing.T) {
 	wii := initTestWiichuckDriver()