Added some tests for digispark i2c connector

platforms/digispark/digispark_adaptor_test.go

@@ -2,11 +2,13 @@ package digispark
 
 import (
 	"errors"
+	"fmt"
 	"strings"
 	"testing"
 
 	"gobot.io/x/gobot"
 	"gobot.io/x/gobot/drivers/gpio"
+	"gobot.io/x/gobot/drivers/i2c"
 	"gobot.io/x/gobot/gobottest"
 )
 
@@ -15,6 +17,7 @@ var _ gobot.Adaptor = (*Adaptor)(nil)
 var _ gpio.DigitalWriter = (*Adaptor)(nil)
 var _ gpio.PwmWriter = (*Adaptor)(nil)
 var _ gpio.ServoWriter = (*Adaptor)(nil)
+var _ i2c.Connector = (*Adaptor)(nil)
 
 type mock struct {
 	locationA         uint8
@@ -25,6 +28,9 @@ type mock struct {
 	pin               uint8
 	mode              uint8
 	state             uint8
+	address           int
+	duration          uint
+	direction         uint8
 }
 
 func (l *mock) digitalWrite(pin uint8, state uint8) error {
@@ -58,6 +64,49 @@ func (l *mock) servoUpdateLocation(locationA uint8, locationB uint8) error {
 	return l.error()
 }
 
+const availableI2cAddress = 0x40
+const maxUint8 = ^uint8(0)
+
+var i2cData = []byte{5, 4, 3, 2, 1, 0}
+
+func (l *mock) i2cInit() error {
+	l.direction = maxUint8
+	return l.error()
+}
+
+func (l *mock) i2cStart(address7bit uint8, direction uint8) error {
+	if address7bit != availableI2cAddress {
+		return fmt.Errorf("Invalid address, only %d is supported", availableI2cAddress)
+	}
+	if err := l.error(); err != nil {
+		return err
+	}
+	l.direction = direction
+	return nil
+}
+
+func (l *mock) i2cWrite(sendBuffer []byte, length int, endWithStop uint8) error {
+	l.direction = 0
+	return l.error()
+}
+
+func (l *mock) i2cRead(readBuffer []byte, length int, endWithStop uint8) error {
+	l.direction = 1
+	if len(readBuffer) < length {
+		length = len(readBuffer)
+	}
+	if len(i2cData) < length {
+		length = len(i2cData)
+	}
+	copy(readBuffer[:length], i2cData[:length])
+	return l.error()
+}
+
+func (l *mock) i2cUpdateDelay(duration uint) error {
+	l.duration = duration
+	return l.error()
+}
+
 var errorFunc = func() error { return nil }
 
 func (l *mock) error() error { return errorFunc() }
@@ -136,3 +185,45 @@ func TestAdaptorPwmWrite(t *testing.T) {
 	err = a.PwmWrite("1", uint8(100))
 	gobottest.Assert(t, err, errors.New("pwm error"))
 }
+
+func TestAdaptorI2c(t *testing.T) {
+	var c i2c.Connection
+	var err error
+	data := []byte{0, 1, 2, 3, 4}
+	dataLen := len(data)
+	count := 0
+
+	a := initTestAdaptor()
+	c, err = a.GetConnection(0x40, 1)
+	gobottest.Assert(t, err, errors.New("Invalid bus number 1, only 0 is supported"))
+	gobottest.Assert(t, c, nil)
+	// init couldn't run, direction is still 0
+	gobottest.Assert(t, a.littleWire.(*mock).direction, uint8(0))
+
+	// connection inits, but start will fail
+	c, err = a.GetConnection(0x39, a.GetDefaultBus())
+	gobottest.Assert(t, err, nil)
+	gobottest.Refute(t, c, nil)
+	gobottest.Assert(t, a.littleWire.(*mock).direction, maxUint8)
+	err = c.(*digisparkI2cConnection).UpdateDelay(uint(100))
+	gobottest.Assert(t, err, nil)
+	gobottest.Assert(t, a.littleWire.(*mock).duration, uint(100))
+	count, err = c.Write(data)
+	gobottest.Assert(t, count, 0)
+	gobottest.Assert(t, err, fmt.Errorf("Invalid address, only %d is supported", availableI2cAddress))
+	gobottest.Assert(t, a.littleWire.(*mock).direction, maxUint8)
+
+	// connection inits, but start will succeed
+	c, err = a.GetConnection(availableI2cAddress, a.GetDefaultBus())
+	gobottest.Assert(t, err, nil)
+	gobottest.Refute(t, c, nil)
+	count, err = c.Write(data)
+	gobottest.Assert(t, count, dataLen)
+	gobottest.Assert(t, err, nil)
+	gobottest.Assert(t, a.littleWire.(*mock).direction, uint8(0))
+	count, err = c.Read(data)
+	gobottest.Assert(t, count, dataLen)
+	gobottest.Assert(t, err, nil)
+	gobottest.Assert(t, a.littleWire.(*mock).direction, uint8(1))
+	gobottest.Assert(t, data, i2cData[:dataLen])
+}