140 lines
2.9 KiB
Go
140 lines
2.9 KiB
Go
package testrunner
|
|
|
|
import (
|
|
"fmt"
|
|
"slices"
|
|
"time"
|
|
|
|
"alox.tool/api"
|
|
"alox.tool/uart"
|
|
)
|
|
|
|
func (tr *TestRunner) RunEchoTest() error {
|
|
frame, err := tr.Expect(api.CmdEcho, []byte{0x01}, api.CmdEcho, 1*time.Second)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if frame.Data[0] != 0x01 {
|
|
return fmt.Errorf("Got % X expected % X", frame.Data[0], 0x01)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (tr *TestRunner) RunVersionTest() error {
|
|
frame, err := tr.Expect(api.CmdVersion, nil, api.CmdVersion, 1*time.Second)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// TODO: Check Version and Buildhash?
|
|
_, err = uart.ParseFrameVersion(*frame)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
v, err := uart.ParseFrameVersion(*frame)
|
|
if v.Version != 1 {
|
|
return fmt.Errorf("Got %d expected %d", v.Version, 1)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (tr *TestRunner) RunClientInfoTest() error {
|
|
_, err := tr.Expect(api.CmdClientInfo, nil, api.CmdClientInfo, 1*time.Second)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// TODO: Real Check
|
|
return nil
|
|
}
|
|
|
|
func (tr *TestRunner) RunClientInputTest() error {
|
|
_, err := tr.Expect(api.CmdClientInput, nil, api.CmdClientInput, 1*time.Second)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// TODO: Real Check
|
|
return nil
|
|
}
|
|
|
|
func (tr *TestRunner) RebuildNetwork() error {
|
|
|
|
// Hardcoded for now
|
|
Clients := map[string]string{
|
|
"C1": "/dev/ttyACM1",
|
|
"C2": "/dev/ttyACM2",
|
|
"C3": "/dev/ttyACM3",
|
|
"C4": "/dev/ttyACM4",
|
|
}
|
|
|
|
// Hardcoded for now
|
|
macAddresses := [][6]byte{
|
|
{0x50, 0x78, 0x7D, 0x18, 0x85, 0xA0},
|
|
{0x50, 0x78, 0x7D, 0x18, 0x7D, 0x74},
|
|
{0x50, 0x78, 0x7D, 0x18, 0x1D, 0x14},
|
|
{0x50, 0x78, 0x7D, 0x18, 0x00, 0x10},
|
|
}
|
|
|
|
// Hardcoded for now
|
|
err := RestartESPOnPort("/dev/ttyACM0")
|
|
if err != nil {
|
|
return fmt.Errorf("Could not Restart Master!")
|
|
}
|
|
time.Sleep(500 * time.Millisecond)
|
|
|
|
for c, p := range Clients {
|
|
fmt.Printf("Restarting Client %v", c)
|
|
err = RestartESPOnPort(p)
|
|
if err != nil {
|
|
fmt.Printf("Could not Restart Client %v on Port %v", c, p)
|
|
return err
|
|
}
|
|
time.Sleep(500 * time.Millisecond)
|
|
}
|
|
|
|
success := false
|
|
var frame *api.Frame
|
|
var clientInfos []api.PayloadClientInfo
|
|
var lastError string
|
|
for i := 0; i <= 5; i++ {
|
|
time.Sleep(1000 * time.Millisecond) // inital sleep for first network setup
|
|
|
|
var err error // for local error scope
|
|
frame, err = tr.Expect(api.CmdClientInfo, nil, api.CmdClientInfo, 1*time.Second)
|
|
if err != nil {
|
|
lastError = "No Uart Message"
|
|
continue
|
|
}
|
|
|
|
clientInfos, err = uart.ParseFrameClientInfo(*frame)
|
|
if err != nil {
|
|
lastError = fmt.Sprintf("Could not parse Message: %v", err)
|
|
continue
|
|
}
|
|
|
|
if len(clientInfos) != len(macAddresses) {
|
|
lastError = fmt.Sprintf("Want %v Clients, got %v Clients", len(macAddresses), len(clientInfos))
|
|
continue
|
|
}
|
|
success = true
|
|
break
|
|
}
|
|
|
|
if !success {
|
|
return fmt.Errorf("%v", lastError)
|
|
}
|
|
|
|
for _, client := range clientInfos {
|
|
if !slices.Contains(macAddresses, client.MACAddr) {
|
|
return fmt.Errorf("Client %v not found in expected list %v", client.MACAddr, macAddresses)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|