mirror of
https://github.com/hybridgroup/gobot.git
synced 2025-04-29 13:49:14 +08:00
614 lines
18 KiB
Go
614 lines
18 KiB
Go
package i2c
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"gobot.io/x/gobot/v2"
|
|
)
|
|
|
|
// this ensures that the implementation is based on i2c.Driver, which implements the gobot.Driver
|
|
// and tests all implementations, so no further tests needed here for gobot.Driver interface
|
|
var _ gobot.Driver = (*PCF8583Driver)(nil)
|
|
|
|
func initTestPCF8583WithStubbedAdaptor() (*PCF8583Driver, *i2cTestAdaptor) {
|
|
a := newI2cTestAdaptor()
|
|
d := NewPCF8583Driver(a)
|
|
_ = d.Start()
|
|
return d, a
|
|
}
|
|
|
|
func TestNewPCF8583Driver(t *testing.T) {
|
|
var di interface{} = NewPCF8583Driver(newI2cTestAdaptor())
|
|
d, ok := di.(*PCF8583Driver)
|
|
if !ok {
|
|
t.Errorf("NewPCF8583Driver() should have returned a *PCF8583Driver")
|
|
}
|
|
assert.NotNil(t, d.Driver)
|
|
assert.True(t, strings.HasPrefix(d.name, "PCF8583"))
|
|
assert.Equal(t, 0x50, d.defaultAddress)
|
|
assert.Equal(t, PCF8583Control(0x00), d.mode)
|
|
assert.Equal(t, 0, d.yearOffset)
|
|
assert.Equal(t, uint8(0x10), d.ramOffset)
|
|
}
|
|
|
|
func TestPCF8583Options(t *testing.T) {
|
|
// This is a general test, that options are applied in constructor by using the common WithBus() option and
|
|
// least one of this driver. Further tests for options can also be done by call of "WithOption(val)(d)".
|
|
d := NewPCF8583Driver(newI2cTestAdaptor(), WithBus(2), WithPCF8583Mode(PCF8583CtrlModeClock50))
|
|
assert.Equal(t, 2, d.GetBusOrDefault(1))
|
|
assert.Equal(t, PCF8583CtrlModeClock50, d.mode)
|
|
}
|
|
|
|
func TestPCF8583CommandsWriteTime(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
readCtrlState := uint8(0x10) // clock 50Hz
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = readCtrlState
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
result := d.Command("WriteTime")(map[string]interface{}{"val": time.Now()})
|
|
// assert
|
|
assert.Nil(t, result.(map[string]interface{})["err"])
|
|
}
|
|
|
|
func TestPCF8583CommandsReadTime(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
d.yearOffset = 2019
|
|
milliSec := 550 * time.Millisecond // 0.55 sec = 550 ms
|
|
want := time.Date(2021, time.December, 24, 18, 00, 00, int(milliSec), time.UTC)
|
|
reg0Val := uint8(0x00) // clock mode 32.768 kHz
|
|
reg1Val := uint8(0x55) // BCD: 1/10 and 1/100 sec (55)
|
|
reg2Val := uint8(0x00) // BCD: 10 and 1 sec (00)
|
|
reg3Val := uint8(0x00) // BCD: 10 and 1 min (00)
|
|
reg4Val := uint8(0x18) // BCD: 10 and 1 hour (18)
|
|
reg5Val := uint8(0xA4) // year (2) and BCD: date (24)
|
|
reg6Val := uint8(0xB2) // weekday 5, bit 5 and bit 7 (0xA0) and BCD: month (0x12)
|
|
returnRead := [2][]uint8{
|
|
{reg0Val},
|
|
{reg1Val, reg2Val, reg3Val, reg4Val, reg5Val, reg6Val},
|
|
}
|
|
// arrange reads
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
rr := returnRead[numCallsRead-1]
|
|
for i := 0; i < len(b); i++ {
|
|
b[i] = rr[i]
|
|
}
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
result := d.Command("ReadTime")(map[string]interface{}{})
|
|
// assert
|
|
assert.Nil(t, result.(map[string]interface{})["err"])
|
|
assert.Equal(t, want, result.(map[string]interface{})["val"])
|
|
}
|
|
|
|
func TestPCF8583CommandsWriteCounter(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
readCtrlState := uint8(0x20) // counter
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = readCtrlState
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
result := d.Command("WriteCounter")(map[string]interface{}{"val": int32(123456)})
|
|
// assert
|
|
assert.Nil(t, result.(map[string]interface{})["err"])
|
|
}
|
|
|
|
func TestPCF8583CommandsReadCounter(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
want := int32(123456)
|
|
reg0Val := uint8(0x20) // counter mode
|
|
reg1Val := uint8(0x56) // BCD: 56
|
|
reg2Val := uint8(0x34) // BCD: 34
|
|
reg3Val := uint8(0x12) // BCD: 12
|
|
returnRead := [2][]uint8{
|
|
{reg0Val},
|
|
{reg1Val, reg2Val, reg3Val},
|
|
}
|
|
// arrange reads
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
rr := returnRead[numCallsRead-1]
|
|
for i := 0; i < len(b); i++ {
|
|
b[i] = rr[i]
|
|
}
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
result := d.Command("ReadCounter")(map[string]interface{}{})
|
|
// assert
|
|
assert.Nil(t, result.(map[string]interface{})["err"])
|
|
assert.Equal(t, want, result.(map[string]interface{})["val"])
|
|
}
|
|
|
|
func TestPCF8583CommandsWriteRAM(t *testing.T) {
|
|
// arrange
|
|
d, _ := initTestPCF8583WithStubbedAdaptor()
|
|
var addressValue = map[string]interface{}{
|
|
"address": uint8(0x12),
|
|
"val": uint8(0x45),
|
|
}
|
|
// act
|
|
result := d.Command("WriteRAM")(addressValue)
|
|
// assert
|
|
assert.Nil(t, result.(map[string]interface{})["err"])
|
|
}
|
|
|
|
func TestPCF8583CommandsReadRAM(t *testing.T) {
|
|
// arrange
|
|
d, _ := initTestPCF8583WithStubbedAdaptor()
|
|
var address = map[string]interface{}{
|
|
"address": uint8(0x34),
|
|
}
|
|
// act
|
|
result := d.Command("ReadRAM")(address)
|
|
// assert
|
|
assert.Nil(t, result.(map[string]interface{})["err"])
|
|
assert.Equal(t, uint8(0), result.(map[string]interface{})["val"])
|
|
}
|
|
|
|
func TestPCF8583WriteTime(t *testing.T) {
|
|
// sequence to write the time:
|
|
// * read control register for get current state and ensure an clock mode is set
|
|
// * write the control register (stop counting)
|
|
// * create the values for date registers (default is 24h mode)
|
|
// * write the clock and calendar registers with auto increment
|
|
// * write the control register (start counting)
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
readCtrlState := uint8(0x07) // 32.768kHz clock mode
|
|
milliSec := 210 * time.Millisecond // 0.21 sec = 210 ms
|
|
initDate := time.Date(2022, time.December, 16, 15, 14, 13, int(milliSec), time.UTC)
|
|
wantCtrlStop := uint8(0x87) // stop counting bit is set
|
|
wantReg1Val := uint8(0x21) // BCD: 1/10 and 1/100 sec (21)
|
|
wantReg2Val := uint8(0x13) // BCD: 10 and 1 sec (13)
|
|
wantReg3Val := uint8(0x14) // BCD: 10 and 1 min (14)
|
|
wantReg4Val := uint8(0x15) // BCD: 10 and 1 hour (15)
|
|
wantReg5Val := uint8(0x16) // year (0) and BCD: date (16)
|
|
wantReg6Val := uint8(0xB2) // weekday 5, bit 5 and bit 7 (0xA0) and BCD: month (0x12)
|
|
wantCrtlStart := uint8(0x07) // stop counting bit is reset
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = readCtrlState
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
err := d.WriteTime(initDate)
|
|
// assert
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, initDate.Year(), d.yearOffset)
|
|
assert.Equal(t, 1, numCallsRead)
|
|
assert.Equal(t, 11, len(a.written))
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[0])
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[1])
|
|
assert.Equal(t, wantCtrlStop, a.written[2])
|
|
assert.Equal(t, wantReg1Val, a.written[3])
|
|
assert.Equal(t, wantReg2Val, a.written[4])
|
|
assert.Equal(t, wantReg3Val, a.written[5])
|
|
assert.Equal(t, wantReg4Val, a.written[6])
|
|
assert.Equal(t, wantReg5Val, a.written[7])
|
|
assert.Equal(t, wantReg6Val, a.written[8])
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[9])
|
|
assert.Equal(t, wantCrtlStart, a.written[10])
|
|
}
|
|
|
|
func TestPCF8583WriteTimeNoTimeModeFails(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
readCtrlState := uint8(0x30) // test mode
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = readCtrlState
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
err := d.WriteTime(time.Now())
|
|
// assert
|
|
assert.NotNil(t, err)
|
|
assert.Contains(t, err.Error(), "wrong mode 0x30")
|
|
assert.Equal(t, 1, len(a.written))
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[0])
|
|
assert.Equal(t, 1, numCallsRead)
|
|
}
|
|
|
|
func TestPCF8583ReadTime(t *testing.T) {
|
|
// sequence to read the time:
|
|
// * read the control register to determine mask flag and ensure an clock mode is set
|
|
// * read the clock and calendar registers with auto increment
|
|
// * create the value out of registers content
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
d.yearOffset = 2020
|
|
milliSec := 210 * time.Millisecond // 0.21 sec = 210 ms
|
|
want := time.Date(2022, time.December, 16, 15, 14, 13, int(milliSec), time.UTC)
|
|
reg0Val := uint8(0x10) // clock mode 50Hz
|
|
reg1Val := uint8(0x21) // BCD: 1/10 and 1/100 sec (21)
|
|
reg2Val := uint8(0x13) // BCD: 10 and 1 sec (13)
|
|
reg3Val := uint8(0x14) // BCD: 10 and 1 min (14)
|
|
reg4Val := uint8(0x15) // BCD: 10 and 1 hour (15)
|
|
reg5Val := uint8(0x96) // year (2) and BCD: date (16)
|
|
reg6Val := uint8(0xB2) // weekday 5, bit 5 and bit 7 (0xA0) and BCD: month (0x12)
|
|
returnRead := [2][]uint8{
|
|
{reg0Val},
|
|
{reg1Val, reg2Val, reg3Val, reg4Val, reg5Val, reg6Val},
|
|
}
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
rr := returnRead[numCallsRead-1]
|
|
for i := 0; i < len(b); i++ {
|
|
b[i] = rr[i]
|
|
}
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.ReadTime()
|
|
// assert
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, 1, len(a.written))
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[0])
|
|
assert.Equal(t, 2, numCallsRead)
|
|
assert.Equal(t, want, got)
|
|
}
|
|
|
|
func TestPCF8583ReadTimeNoTimeModeFails(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
readCtrlState := uint8(0x20) // counter mode
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = readCtrlState
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.ReadTime()
|
|
// assert
|
|
assert.NotNil(t, err)
|
|
assert.Contains(t, err.Error(), "wrong mode 0x20")
|
|
assert.Equal(t, time.Time{}, got)
|
|
assert.Equal(t, 1, len(a.written))
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[0])
|
|
assert.Equal(t, 1, numCallsRead)
|
|
}
|
|
|
|
func TestPCF8583WriteCounter(t *testing.T) {
|
|
// sequence to write the counter:
|
|
// * read control register for get current state and ensure the event counter mode is set
|
|
// * write the control register (stop counting)
|
|
// * create the values for counter registers
|
|
// * write the counter registers
|
|
// * write the control register (start counting)
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
readCtrlState := uint8(0x27) // counter mode
|
|
initCount := int32(654321) // 6 digits used of 10 possible with int32
|
|
wantCtrlStop := uint8(0xA7) // stop counting bit is set
|
|
wantReg1Val := uint8(0x21) // BCD: 21
|
|
wantReg2Val := uint8(0x43) // BCD: 43
|
|
wantReg3Val := uint8(0x65) // BCD: 65
|
|
wantCtrlStart := uint8(0x27) // counter mode
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = readCtrlState
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
err := d.WriteCounter(initCount)
|
|
// assert
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, 1, numCallsRead)
|
|
assert.Equal(t, 8, len(a.written))
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[0])
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[1])
|
|
assert.Equal(t, wantCtrlStop, a.written[2])
|
|
assert.Equal(t, wantReg1Val, a.written[3])
|
|
assert.Equal(t, wantReg2Val, a.written[4])
|
|
assert.Equal(t, wantReg3Val, a.written[5])
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[6])
|
|
assert.Equal(t, wantCtrlStart, a.written[7])
|
|
}
|
|
|
|
func TestPCF8583WriteCounterNoCounterModeFails(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
readCtrlState := uint8(0x10) // 50Hz mode
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = readCtrlState
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
err := d.WriteCounter(123)
|
|
// assert
|
|
assert.NotNil(t, err)
|
|
assert.Contains(t, err.Error(), "wrong mode 0x10")
|
|
assert.Equal(t, 1, len(a.written))
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[0])
|
|
assert.Equal(t, 1, numCallsRead)
|
|
}
|
|
|
|
func TestPCF8583ReadCounter(t *testing.T) {
|
|
// sequence to read the counter:
|
|
// * read the control register to ensure the event counter mode is set
|
|
// * read the counter registers
|
|
// * create the value out of registers content
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
want := int32(654321)
|
|
reg0Val := uint8(0x20) // counter mode
|
|
reg1Val := uint8(0x21) // BCD: 21
|
|
reg2Val := uint8(0x43) // BCD: 43
|
|
reg3Val := uint8(0x65) // BCD: 65
|
|
returnRead := [2][]uint8{
|
|
{reg0Val},
|
|
{reg1Val, reg2Val, reg3Val},
|
|
}
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
rr := returnRead[numCallsRead-1]
|
|
for i := 0; i < len(b); i++ {
|
|
b[i] = rr[i]
|
|
}
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.ReadCounter()
|
|
// assert
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, 1, len(a.written))
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[0])
|
|
assert.Equal(t, 2, numCallsRead)
|
|
assert.Equal(t, want, got)
|
|
}
|
|
|
|
func TestPCF8583ReadCounterNoCounterModeFails(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
readCtrlState := uint8(0x30) // test mode
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = readCtrlState
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.ReadCounter()
|
|
// assert
|
|
assert.NotNil(t, err)
|
|
assert.Contains(t, err.Error(), "wrong mode 0x30")
|
|
assert.Equal(t, int32(0), got)
|
|
assert.Equal(t, 1, len(a.written))
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[0])
|
|
assert.Equal(t, 1, numCallsRead)
|
|
}
|
|
|
|
func TestPCF8583WriteRam(t *testing.T) {
|
|
// sequence to write the RAM:
|
|
// * calculate the RAM address and check for valid range
|
|
// * write the given value to the given RAM address
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
wantRAMAddress := uint8(0xFF)
|
|
wantRAMValue := uint8(0xEF)
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
err := d.WriteRAM(wantRAMAddress-pcf8583RamOffset, wantRAMValue)
|
|
// assert
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, 2, len(a.written))
|
|
assert.Equal(t, wantRAMAddress, a.written[0])
|
|
assert.Equal(t, wantRAMValue, a.written[1])
|
|
}
|
|
|
|
func TestPCF8583WriteRamAddressOverflowFails(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
// act
|
|
err := d.WriteRAM(uint8(0xF0), 15)
|
|
// assert
|
|
assert.NotNil(t, err)
|
|
assert.Contains(t, err.Error(), "overflow 256")
|
|
assert.Equal(t, 0, len(a.written))
|
|
}
|
|
|
|
func TestPCF8583ReadRam(t *testing.T) {
|
|
// sequence to read the RAM:
|
|
// * calculate the RAM address and check for valid range
|
|
// * read the value from the given RAM address
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
wantRAMAddress := uint8(pcf8583RamOffset)
|
|
want := uint8(0xAB)
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = want
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.ReadRAM(wantRAMAddress - pcf8583RamOffset)
|
|
// assert
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, want, got)
|
|
assert.Equal(t, 1, len(a.written))
|
|
assert.Equal(t, wantRAMAddress, a.written[0])
|
|
assert.Equal(t, 1, numCallsRead)
|
|
}
|
|
|
|
func TestPCF8583ReadRamAddressOverflowFails(t *testing.T) {
|
|
// arrange
|
|
d, a := initTestPCF8583WithStubbedAdaptor()
|
|
a.written = []byte{} // reset writes of Start() and former test
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
return len(b), nil
|
|
}
|
|
// act
|
|
got, err := d.ReadRAM(uint8(0xF0))
|
|
// assert
|
|
assert.NotNil(t, err)
|
|
assert.Contains(t, err.Error(), "overflow 256")
|
|
assert.Equal(t, uint8(0), got)
|
|
assert.Equal(t, 0, len(a.written))
|
|
assert.Equal(t, 0, numCallsRead)
|
|
}
|
|
|
|
func TestPCF8583_initializeNoModeSwitch(t *testing.T) {
|
|
// arrange
|
|
a := newI2cTestAdaptor()
|
|
d := NewPCF8583Driver(a)
|
|
a.written = []byte{} // reset writes of former tests
|
|
readCtrlState := uint8(0x01) // 32.768kHz clock mode
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = readCtrlState
|
|
return len(b), nil
|
|
}
|
|
// act, assert - initialize() must be called on Start()
|
|
err := d.Start()
|
|
// assert
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, 1, numCallsRead)
|
|
assert.Equal(t, 1, len(a.written))
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[0])
|
|
}
|
|
|
|
func TestPCF8583_initializeWithModeSwitch(t *testing.T) {
|
|
// sequence to change mode:
|
|
// * read control register for get current state
|
|
// * reset old mode bits and set new mode bit
|
|
// * write the control register
|
|
// arrange
|
|
a := newI2cTestAdaptor()
|
|
d := NewPCF8583Driver(a)
|
|
d.mode = PCF8583CtrlModeCounter
|
|
a.written = []byte{} // reset writes of former tests
|
|
readCtrlState := uint8(0x02) // 32.768kHz clock mode
|
|
wantReg0Val := uint8(0x22) // event counter mode
|
|
// arrange writes
|
|
a.i2cWriteImpl = func(b []byte) (int, error) {
|
|
return len(b), nil
|
|
}
|
|
// arrange reads
|
|
numCallsRead := 0
|
|
a.i2cReadImpl = func(b []byte) (int, error) {
|
|
numCallsRead++
|
|
b[len(b)-1] = readCtrlState
|
|
return len(b), nil
|
|
}
|
|
// act, assert - initialize() must be called on Start()
|
|
err := d.Start()
|
|
// assert
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, 1, numCallsRead)
|
|
assert.Equal(t, 3, len(a.written))
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[0])
|
|
assert.Equal(t, uint8(pcf8583Reg_CTRL), a.written[1])
|
|
assert.Equal(t, uint8(wantReg0Val), a.written[2])
|
|
}
|