mirror of
https://github.com/hybridgroup/gobot.git
synced 2025-04-26 13:48:49 +08:00
307 lines
7.4 KiB
Go
307 lines
7.4 KiB
Go
package i2c
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"gobot.io/x/gobot/v2"
|
|
)
|
|
|
|
var _ gobot.Driver = (*Adafruit1109Driver)(nil)
|
|
|
|
func initTestAdafruit1109WithStubbedAdaptor() (*Adafruit1109Driver, *i2cTestAdaptor) {
|
|
adaptor := newI2cTestAdaptor()
|
|
return NewAdafruit1109Driver(adaptor), adaptor
|
|
}
|
|
|
|
func TestNewAdafruit1109Driver(t *testing.T) {
|
|
var di interface{} = NewAdafruit1109Driver(newI2cTestAdaptor())
|
|
d, ok := di.(*Adafruit1109Driver)
|
|
if !ok {
|
|
require.Fail(t, "NewAdafruit1109Driver() should have returned a *Adafruit1109Driver")
|
|
}
|
|
assert.NotNil(t, d.Driver)
|
|
assert.NotNil(t, d.Connection())
|
|
assert.True(t, strings.HasPrefix(d.Name(), "Adafruit1109"))
|
|
assert.Contains(t, d.Name(), "MCP23017")
|
|
assert.Contains(t, d.Name(), "HD44780")
|
|
assert.NotNil(t, d.MCP23017Driver)
|
|
assert.NotNil(t, d.HD44780Driver)
|
|
assert.NotNil(t, d.redPin)
|
|
assert.NotNil(t, d.greenPin)
|
|
assert.NotNil(t, d.bluePin)
|
|
assert.NotNil(t, d.selectPin)
|
|
assert.NotNil(t, d.upPin)
|
|
assert.NotNil(t, d.downPin)
|
|
assert.NotNil(t, d.leftPin)
|
|
assert.NotNil(t, d.rightPin)
|
|
assert.NotNil(t, d.rwPin)
|
|
assert.NotNil(t, d.rsPin)
|
|
assert.NotNil(t, d.enPin)
|
|
assert.NotNil(t, d.dataPinD4)
|
|
assert.NotNil(t, d.dataPinD5)
|
|
assert.NotNil(t, d.dataPinD6)
|
|
assert.NotNil(t, d.dataPinD7)
|
|
}
|
|
|
|
func TestAdafruit1109Connect(t *testing.T) {
|
|
d, _ := initTestAdafruit1109WithStubbedAdaptor()
|
|
require.NoError(t, d.Connect())
|
|
}
|
|
|
|
func TestAdafruit1109Finalize(t *testing.T) {
|
|
d, _ := initTestAdafruit1109WithStubbedAdaptor()
|
|
require.NoError(t, d.Finalize())
|
|
}
|
|
|
|
func TestAdafruit1109SetName(t *testing.T) {
|
|
d, _ := initTestAdafruit1109WithStubbedAdaptor()
|
|
d.SetName("foo")
|
|
assert.Equal(t, "foo", d.name)
|
|
}
|
|
|
|
func TestAdafruit1109Start(t *testing.T) {
|
|
d, _ := initTestAdafruit1109WithStubbedAdaptor()
|
|
require.NoError(t, d.Start())
|
|
}
|
|
|
|
func TestAdafruit1109StartWriteErr(t *testing.T) {
|
|
d, adaptor := initTestAdafruit1109WithStubbedAdaptor()
|
|
adaptor.i2cWriteImpl = func([]byte) (int, error) {
|
|
return 0, errors.New("write error")
|
|
}
|
|
require.ErrorContains(t, d.Start(), "write error")
|
|
}
|
|
|
|
func TestAdafruit1109StartReadErr(t *testing.T) {
|
|
d, adaptor := initTestAdafruit1109WithStubbedAdaptor()
|
|
adaptor.i2cReadImpl = func([]byte) (int, error) {
|
|
return 0, errors.New("read error")
|
|
}
|
|
require.ErrorContains(t, d.Start(), "MCP write-read: MCP write-ReadByteData(reg=0): read error")
|
|
}
|
|
|
|
func TestAdafruit1109Halt(t *testing.T) {
|
|
d, _ := initTestAdafruit1109WithStubbedAdaptor()
|
|
_ = d.Start()
|
|
require.NoError(t, d.Halt())
|
|
}
|
|
|
|
func TestAdafruit1109DigitalRead(t *testing.T) {
|
|
tests := map[string]struct {
|
|
read uint8
|
|
wantReg uint8
|
|
}{
|
|
"A_0": {read: 0x01, wantReg: 0x12},
|
|
"A_1": {read: 0x02, wantReg: 0x12},
|
|
"A_2": {read: 0x04, wantReg: 0x12},
|
|
"A_3": {read: 0x08, wantReg: 0x12},
|
|
"A_4": {read: 0x10, wantReg: 0x12},
|
|
"A_5": {read: 0x20, wantReg: 0x12},
|
|
"A_6": {read: 0x40, wantReg: 0x12},
|
|
"A_7": {read: 0x80, wantReg: 0x12},
|
|
"B_0": {read: 0x01, wantReg: 0x13},
|
|
"B_1": {read: 0x02, wantReg: 0x13},
|
|
"B_2": {read: 0x04, wantReg: 0x13},
|
|
"B_3": {read: 0x08, wantReg: 0x13},
|
|
"B_4": {read: 0x10, wantReg: 0x13},
|
|
"B_5": {read: 0x20, wantReg: 0x13},
|
|
"B_6": {read: 0x40, wantReg: 0x13},
|
|
"B_7": {read: 0x80, wantReg: 0x13},
|
|
}
|
|
for name, tc := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestAdafruit1109WithStubbedAdaptor()
|
|
_ = d.Start()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[0] = tc.read
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.DigitalRead(name)
|
|
// assert
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 1, numCallsRead)
|
|
assert.Len(t, a.written, 1)
|
|
assert.Equal(t, tc.wantReg, a.written[0])
|
|
assert.Equal(t, 1, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAdafruit1109SelectButton(t *testing.T) {
|
|
tests := map[string]struct {
|
|
read uint8
|
|
want uint8
|
|
}{
|
|
"A0_not_pressed": {read: 0xFE, want: 0},
|
|
"A0_pressed": {read: 0x01, want: 1},
|
|
}
|
|
for name, tc := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestAdafruit1109WithStubbedAdaptor()
|
|
_ = d.Start()
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[0] = tc.read
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.SelectButton()
|
|
// assert
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 1, numCallsRead)
|
|
assert.Equal(t, tc.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAdafruit1109UpButton(t *testing.T) {
|
|
tests := map[string]struct {
|
|
read uint8
|
|
want uint8
|
|
}{
|
|
"A3_not_pressed": {read: 0xF7, want: 0},
|
|
"A3_pressed": {read: 0x08, want: 1},
|
|
}
|
|
for name, tc := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestAdafruit1109WithStubbedAdaptor()
|
|
_ = d.Start()
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[0] = tc.read
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.UpButton()
|
|
// assert
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 1, numCallsRead)
|
|
assert.Equal(t, tc.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAdafruit1109DownButton(t *testing.T) {
|
|
tests := map[string]struct {
|
|
read uint8
|
|
want uint8
|
|
}{
|
|
"A2_not_pressed": {read: 0xFB, want: 0},
|
|
"A2_pressed": {read: 0x04, want: 1},
|
|
}
|
|
for name, tc := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestAdafruit1109WithStubbedAdaptor()
|
|
_ = d.Start()
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[0] = tc.read
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.DownButton()
|
|
// assert
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 1, numCallsRead)
|
|
assert.Equal(t, tc.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAdafruit1109LeftButton(t *testing.T) {
|
|
tests := map[string]struct {
|
|
read uint8
|
|
want uint8
|
|
}{
|
|
"A4_not_pressed": {read: 0xEF, want: 0},
|
|
"A4_pressed": {read: 0x10, want: 1},
|
|
}
|
|
for name, tc := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestAdafruit1109WithStubbedAdaptor()
|
|
_ = d.Start()
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[0] = tc.read
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.LeftButton()
|
|
// assert
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 1, numCallsRead)
|
|
assert.Equal(t, tc.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAdafruit1109RightButton(t *testing.T) {
|
|
tests := map[string]struct {
|
|
read uint8
|
|
want uint8
|
|
}{
|
|
"A1_not_pressed": {read: 0xFD, want: 0},
|
|
"A1_pressed": {read: 0x02, want: 1},
|
|
}
|
|
for name, tc := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestAdafruit1109WithStubbedAdaptor()
|
|
_ = d.Start()
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[0] = tc.read
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.RightButton()
|
|
// assert
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 1, numCallsRead)
|
|
assert.Equal(t, tc.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestAdafruit1109_parseID(t *testing.T) {
|
|
// arrange
|
|
ports := []string{"A", "B"}
|
|
for _, port := range ports {
|
|
for pin := uint8(0); pin <= 7; pin++ {
|
|
id := fmt.Sprintf("%s_%d", port, pin)
|
|
t.Run(id, func(t *testing.T) {
|
|
// act
|
|
got := adafruit1109ParseID(id)
|
|
// assert
|
|
assert.Equal(t, adafruit1109PortPin{port, pin}, got)
|
|
})
|
|
}
|
|
}
|
|
}
|