mirror of https://github.com/periph/devices
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
340 lines
7.0 KiB
Go
340 lines
7.0 KiB
Go
// Copyright 2018 The Periph Authors. All rights reserved.
|
|
// Use of this source code is governed under the Apache License, Version 2.0
|
|
// that can be found in the LICENSE file.
|
|
|
|
package pca9548
|
|
|
|
import (
|
|
"strconv"
|
|
"testing"
|
|
|
|
"periph.io/x/conn/v3/i2c/i2creg"
|
|
"periph.io/x/conn/v3/i2c/i2ctest"
|
|
"periph.io/x/conn/v3/physic"
|
|
"periph.io/x/host/v3"
|
|
)
|
|
|
|
func TestNew(t *testing.T) {
|
|
tests := []struct {
|
|
tx []i2ctest.IO
|
|
address int
|
|
wantErr bool
|
|
}{
|
|
{
|
|
tx: []i2ctest.IO{{Addr: 0x70, W: nil, R: []byte{0xFF}}},
|
|
address: 0x70,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
tx: []i2ctest.IO{{Addr: 0x70, W: nil, R: nil}},
|
|
address: 0x70,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
tx: []i2ctest.IO{{Addr: 0x50, W: nil, R: nil}},
|
|
address: 0x50,
|
|
wantErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
bus := &i2ctest.Playback{Ops: tt.tx, DontPanic: true}
|
|
_, err := New(bus, &Opts{Addr: tt.address})
|
|
|
|
if err != nil && !tt.wantErr {
|
|
t.Errorf("got unexpected error %v", err)
|
|
}
|
|
|
|
if err == nil && tt.wantErr {
|
|
t.Errorf("expected error but got none")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRegisterPorts(t *testing.T) {
|
|
tests := []struct {
|
|
alias string
|
|
expect []string
|
|
}{
|
|
{
|
|
"mux",
|
|
[]string{
|
|
"playback-pca9548-70-0",
|
|
"playback-pca9548-70-1",
|
|
"playback-pca9548-70-2",
|
|
"playback-pca9548-70-3",
|
|
"playback-pca9548-70-4",
|
|
"playback-pca9548-70-5",
|
|
"playback-pca9548-70-6",
|
|
"playback-pca9548-70-7",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
bus := &i2ctest.Playback{
|
|
Ops: []i2ctest.IO{
|
|
{Addr: 0x70, W: nil, R: []byte{0xFF}},
|
|
},
|
|
DontPanic: true,
|
|
}
|
|
host.Init()
|
|
|
|
mux, err := New(bus, &DefaultOpts)
|
|
if err != nil {
|
|
t.Fatalf("failed to create I²C mux: %v", err)
|
|
}
|
|
|
|
portNames, err := mux.RegisterPorts(tt.alias)
|
|
if err != nil {
|
|
t.Fatalf("failed to create I²C mux: %v", err)
|
|
}
|
|
for i, port := range tt.expect {
|
|
if portNames[i] != port {
|
|
t.Errorf("expected port name %v but got %v", portNames[i], port)
|
|
} else if err := i2creg.Unregister(port); err != nil {
|
|
t.Errorf("failed to Unregister port %d: %v", i, err)
|
|
}
|
|
}
|
|
}
|
|
// Failing Case.
|
|
for _, tt := range tests {
|
|
bus := &i2ctest.Playback{
|
|
Ops: []i2ctest.IO{
|
|
{Addr: 0x70, W: nil, R: []byte{0xFF}},
|
|
},
|
|
DontPanic: true,
|
|
}
|
|
host.Init()
|
|
|
|
mux, err := New(bus, &DefaultOpts)
|
|
if err != nil {
|
|
t.Fatalf("failed to create I²C mux: %v", err)
|
|
}
|
|
|
|
if _, err := mux.RegisterPorts(tt.alias); err != nil {
|
|
t.Fatalf("failed to create I²C mux: %v", err)
|
|
}
|
|
if _, err := mux.RegisterPorts(tt.alias); err == nil {
|
|
t.Fatal("expected second registration to fail", err)
|
|
}
|
|
for i, port := range tt.expect {
|
|
if err := i2creg.Unregister(port); err != nil {
|
|
t.Errorf("failed to Unregister port %d: %v", i, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDev_Halt(t *testing.T) {
|
|
d := &Dev{}
|
|
err := d.Halt()
|
|
if err != nil {
|
|
t.Errorf("expected error but got none")
|
|
}
|
|
}
|
|
|
|
func TestDev_String(t *testing.T) {
|
|
tests := []struct {
|
|
address uint16
|
|
want string
|
|
}{
|
|
{address: 0x70, want: "pca9548-70"},
|
|
{address: 0x71, want: "pca9548-71"},
|
|
{address: 0x72, want: "pca9548-72"},
|
|
{address: 0x73, want: "pca9548-73"},
|
|
{address: 0x74, want: "pca9548-74"},
|
|
}
|
|
for _, tt := range tests {
|
|
bus := &i2ctest.Playback{
|
|
Ops: []i2ctest.IO{
|
|
{Addr: tt.address, W: nil, R: []byte{0xFF}},
|
|
},
|
|
DontPanic: false,
|
|
}
|
|
host.Init()
|
|
|
|
mux, err := New(bus, &Opts{Addr: int(tt.address)})
|
|
if err != nil {
|
|
t.Fatalf("failed to create I²C mux: %v", err)
|
|
}
|
|
|
|
if got := mux.String(); got != tt.want {
|
|
t.Errorf("Dev.String() = %v, want %v", got, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDev_Tx(t *testing.T) {
|
|
var tests = []struct {
|
|
alias string
|
|
openPort string
|
|
initialPort int
|
|
address uint16
|
|
tx []i2ctest.IO
|
|
wantErr bool
|
|
}{
|
|
{
|
|
alias: "mux",
|
|
openPort: "mux0",
|
|
initialPort: 0,
|
|
address: 0x30,
|
|
tx: []i2ctest.IO{
|
|
{Addr: 0x70, W: nil, R: []byte{0xFF}},
|
|
{Addr: 0x70, W: []byte{0x01}, R: []byte{}},
|
|
{Addr: 0x30, W: []byte{0xAA}, R: []byte{0xBB}},
|
|
},
|
|
},
|
|
{
|
|
alias: "mux",
|
|
openPort: "mux0",
|
|
initialPort: 0,
|
|
address: 0x70,
|
|
tx: []i2ctest.IO{
|
|
{Addr: 0x70, W: nil, R: []byte{0xFF}},
|
|
{Addr: 0x70, W: []byte{0x01}, R: []byte{}},
|
|
{Addr: 0x70, W: []byte{0xAA}, R: []byte{0xBB}},
|
|
},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
alias: "mux",
|
|
openPort: "mux0",
|
|
initialPort: 0,
|
|
address: 0x30,
|
|
tx: []i2ctest.IO{
|
|
{Addr: 0x70, W: nil, R: []byte{0xFF}},
|
|
},
|
|
wantErr: true,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
|
|
bus := &i2ctest.Playback{
|
|
Ops: tt.tx,
|
|
DontPanic: true,
|
|
}
|
|
host.Init()
|
|
|
|
mux, err := New(bus, &DefaultOpts)
|
|
if err != nil {
|
|
t.Fatalf("failed to open I²C: %v", err)
|
|
}
|
|
|
|
_, err = mux.RegisterPorts(tt.alias)
|
|
if err != nil {
|
|
t.Fatalf("failed to open I²C: %v", err)
|
|
}
|
|
|
|
muxbus, err := i2creg.Open(tt.openPort)
|
|
if err != nil {
|
|
t.Fatalf("failed to open I²C: %v", err)
|
|
}
|
|
defer muxbus.Close()
|
|
err = muxbus.Tx(tt.address, []byte{0xAA}, []byte{0xBB})
|
|
|
|
if err != nil && !tt.wantErr {
|
|
t.Errorf("expected no error but got: %v", err)
|
|
}
|
|
if err == nil && tt.wantErr {
|
|
t.Errorf("expected error")
|
|
}
|
|
|
|
// Cleanup
|
|
for i := 0; i < 8; i++ {
|
|
if err := i2creg.Unregister("playback-" + mux.String() + "-" + strconv.Itoa(i)); err != nil {
|
|
t.Errorf("failed to Unregister port %d: %v", i, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_port_Tx(t *testing.T) {
|
|
tests := []struct {
|
|
p *port
|
|
wantErr bool
|
|
}{
|
|
{
|
|
p: &port{number: 6},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
p: &port{number: 0x6, mux: &Dev{address: 0x70, activePort: 6,
|
|
c: &i2ctest.Playback{
|
|
Ops: []i2ctest.IO{{Addr: 0x1, W: nil, R: nil}},
|
|
},
|
|
},
|
|
},
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
err := tt.p.Tx(0x01, nil, nil)
|
|
|
|
if err != nil && !tt.wantErr {
|
|
t.Errorf("got unexpected error %v", err)
|
|
}
|
|
|
|
if err == nil && tt.wantErr {
|
|
t.Errorf("expected error but got none")
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func Test_port_Close(t *testing.T) {
|
|
|
|
p := &port{number: 6}
|
|
|
|
p.Close()
|
|
if err := p.Tx(0x01, nil, nil); err == nil {
|
|
t.Errorf("expected error but got none")
|
|
}
|
|
|
|
}
|
|
|
|
func Test_port_String(t *testing.T) {
|
|
bus := &i2ctest.Playback{
|
|
Ops: []i2ctest.IO{{Addr: 0x70, W: nil, R: []byte{0xFF}}},
|
|
DontPanic: true,
|
|
}
|
|
host.Init()
|
|
|
|
mux, err := New(bus, &DefaultOpts)
|
|
if err != nil {
|
|
t.Fatalf("failed to open I²C: %v", err)
|
|
}
|
|
|
|
_, err = mux.RegisterPorts("mux")
|
|
if err != nil {
|
|
t.Fatalf("failed to open I²C: %v", err)
|
|
}
|
|
|
|
muxbus, err := i2creg.Open("mux0")
|
|
if err != nil {
|
|
t.Fatalf("failed to open I²C: %v", err)
|
|
}
|
|
|
|
expected := "Port:playback-pca9548-70-0(mux0)"
|
|
got := muxbus.String()
|
|
if got != expected {
|
|
t.Errorf("expected: \n%v but got: \n%v", expected, got)
|
|
}
|
|
|
|
// Cleanup
|
|
for i := 0; i < 8; i++ {
|
|
if err := i2creg.Unregister("playback-" + mux.String() + "-" + strconv.Itoa(i)); err != nil {
|
|
t.Errorf("failed to Unregister port %d: %v", i, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_port_SetSpeed(t *testing.T) {
|
|
p := &port{}
|
|
err := p.SetSpeed(400 * physic.KiloHertz)
|
|
if err == nil {
|
|
t.Errorf("expected error but got none")
|
|
}
|
|
}
|