gobot.io/x/gobot/v2@v2.1.0/drivers/i2c/adafruit_driver_test.go (about)

     1  package i2c
     2  
     3  import (
     4  	"errors"
     5  	"strings"
     6  	"testing"
     7  
     8  	"gobot.io/x/gobot/v2"
     9  	"gobot.io/x/gobot/v2/gobottest"
    10  )
    11  
    12  // this ensures that the implementation implements the gobot.Driver interface
    13  var _ gobot.Driver = (*AdafruitMotorHatDriver)(nil)
    14  
    15  // --------- HELPERS
    16  func initTestAdafruitMotorHatDriver() (driver *AdafruitMotorHatDriver) {
    17  	driver, _ = initTestAdafruitMotorHatDriverWithStubbedAdaptor()
    18  	return
    19  }
    20  
    21  func initTestAdafruitMotorHatDriverWithStubbedAdaptor() (*AdafruitMotorHatDriver, *i2cTestAdaptor) {
    22  	adaptor := newI2cTestAdaptor()
    23  	return NewAdafruitMotorHatDriver(adaptor), adaptor
    24  }
    25  
    26  // --------- TESTS
    27  func TestNewAdafruitMotorHatDriver(t *testing.T) {
    28  	var di interface{} = NewAdafruitMotorHatDriver(newI2cTestAdaptor())
    29  	d, ok := di.(*AdafruitMotorHatDriver)
    30  	if !ok {
    31  		t.Errorf("AdafruitMotorHatDriver() should have returned a *AdafruitMotorHatDriver")
    32  	}
    33  	gobottest.Assert(t, strings.HasPrefix(d.Name(), "AdafruitMotorHat"), true)
    34  }
    35  
    36  // Methods
    37  func TestAdafruitMotorHatDriverStart(t *testing.T) {
    38  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
    39  	gobottest.Refute(t, ada.Connection(), nil)
    40  	gobottest.Assert(t, ada.Start(), nil)
    41  }
    42  
    43  func TestAdafruitMotorHatDriverStartWriteError(t *testing.T) {
    44  	d, adaptor := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
    45  	adaptor.i2cWriteImpl = func([]byte) (int, error) {
    46  		return 0, errors.New("write error")
    47  	}
    48  	gobottest.Assert(t, d.Start(), errors.New("write error"))
    49  }
    50  
    51  func TestAdafruitMotorHatDriverStartReadError(t *testing.T) {
    52  	d, adaptor := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
    53  	adaptor.i2cReadImpl = func([]byte) (int, error) {
    54  		return 0, errors.New("read error")
    55  	}
    56  	gobottest.Assert(t, d.Start(), errors.New("read error"))
    57  }
    58  
    59  func TestAdafruitMotorHatDriverStartConnectError(t *testing.T) {
    60  	d, adaptor := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
    61  	adaptor.Testi2cConnectErr(true)
    62  	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
    63  }
    64  
    65  func TestAdafruitMotorHatDriverHalt(t *testing.T) {
    66  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
    67  
    68  	gobottest.Assert(t, ada.Halt(), nil)
    69  }
    70  
    71  func TestSetHatAddresses(t *testing.T) {
    72  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
    73  
    74  	motorHatAddr := 0x61
    75  	servoHatAddr := 0x41
    76  	gobottest.Assert(t, ada.SetMotorHatAddress(motorHatAddr), nil)
    77  	gobottest.Assert(t, ada.SetServoHatAddress(servoHatAddr), nil)
    78  }
    79  
    80  func TestAdafruitMotorHatDriverSetServoMotorFreq(t *testing.T) {
    81  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
    82  
    83  	gobottest.Assert(t, ada.Start(), nil)
    84  
    85  	freq := 60.0
    86  	err := ada.SetServoMotorFreq(freq)
    87  	gobottest.Assert(t, err, nil)
    88  }
    89  
    90  func TestAdafruitMotorHatDriverSetServoMotorFreqError(t *testing.T) {
    91  	ada, a := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
    92  
    93  	gobottest.Assert(t, ada.Start(), nil)
    94  	a.i2cWriteImpl = func([]byte) (int, error) {
    95  		return 0, errors.New("write error")
    96  	}
    97  
    98  	freq := 60.0
    99  	gobottest.Assert(t, ada.SetServoMotorFreq(freq), errors.New("write error"))
   100  }
   101  
   102  func TestAdafruitMotorHatDriverSetServoMotorPulse(t *testing.T) {
   103  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   104  
   105  	gobottest.Assert(t, ada.Start(), nil)
   106  
   107  	var channel byte = 7
   108  	var on int32 = 1234
   109  	var off int32 = 4321
   110  	err := ada.SetServoMotorPulse(channel, on, off)
   111  	gobottest.Assert(t, err, nil)
   112  }
   113  
   114  func TestAdafruitMotorHatDriverSetServoMotorPulseError(t *testing.T) {
   115  	ada, a := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   116  
   117  	gobottest.Assert(t, ada.Start(), nil)
   118  	a.i2cWriteImpl = func([]byte) (int, error) {
   119  		return 0, errors.New("write error")
   120  	}
   121  
   122  	var channel byte = 7
   123  	var on int32 = 1234
   124  	var off int32 = 4321
   125  	gobottest.Assert(t, ada.SetServoMotorPulse(channel, on, off), errors.New("write error"))
   126  }
   127  
   128  func TestAdafruitMotorHatDriverSetDCMotorSpeed(t *testing.T) {
   129  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   130  
   131  	gobottest.Assert(t, ada.Start(), nil)
   132  
   133  	dcMotor := 1
   134  	var speed int32 = 255
   135  	err := ada.SetDCMotorSpeed(dcMotor, speed)
   136  	gobottest.Assert(t, err, nil)
   137  }
   138  
   139  func TestAdafruitMotorHatDriverSetDCMotorSpeedError(t *testing.T) {
   140  	ada, a := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   141  
   142  	gobottest.Assert(t, ada.Start(), nil)
   143  	a.i2cWriteImpl = func([]byte) (int, error) {
   144  		return 0, errors.New("write error")
   145  	}
   146  
   147  	gobottest.Assert(t, ada.SetDCMotorSpeed(1, 255), errors.New("write error"))
   148  }
   149  
   150  func TestAdafruitMotorHatDriverRunDCMotor(t *testing.T) {
   151  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   152  
   153  	gobottest.Assert(t, ada.Start(), nil)
   154  
   155  	dcMotor := 1
   156  	gobottest.Assert(t, ada.RunDCMotor(dcMotor, AdafruitForward), nil)
   157  	gobottest.Assert(t, ada.RunDCMotor(dcMotor, AdafruitBackward), nil)
   158  	gobottest.Assert(t, ada.RunDCMotor(dcMotor, AdafruitRelease), nil)
   159  }
   160  
   161  func TestAdafruitMotorHatDriverRunDCMotorError(t *testing.T) {
   162  	ada, a := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   163  	gobottest.Assert(t, ada.Start(), nil)
   164  	a.i2cWriteImpl = func([]byte) (int, error) {
   165  		return 0, errors.New("write error")
   166  	}
   167  
   168  	dcMotor := 1
   169  	gobottest.Assert(t, ada.RunDCMotor(dcMotor, AdafruitForward), errors.New("write error"))
   170  	gobottest.Assert(t, ada.RunDCMotor(dcMotor, AdafruitBackward), errors.New("write error"))
   171  	gobottest.Assert(t, ada.RunDCMotor(dcMotor, AdafruitRelease), errors.New("write error"))
   172  }
   173  
   174  func TestAdafruitMotorHatDriverSetStepperMotorSpeed(t *testing.T) {
   175  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   176  
   177  	gobottest.Assert(t, ada.Start(), nil)
   178  
   179  	stepperMotor := 1
   180  	rpm := 30
   181  	gobottest.Assert(t, ada.SetStepperMotorSpeed(stepperMotor, rpm), nil)
   182  }
   183  
   184  func TestAdafruitMotorHatDriverStepperMicroStep(t *testing.T) {
   185  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   186  
   187  	gobottest.Assert(t, ada.Start(), nil)
   188  
   189  	// NOTE: not using the direction and style constants to prevent importing
   190  	// the i2c package
   191  	stepperMotor := 0
   192  	steps := 50
   193  	err := ada.Step(stepperMotor, steps, 1, 3)
   194  	gobottest.Assert(t, err, nil)
   195  }
   196  
   197  func TestAdafruitMotorHatDriverStepperSingleStep(t *testing.T) {
   198  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   199  
   200  	gobottest.Assert(t, ada.Start(), nil)
   201  
   202  	// NOTE: not using the direction and style constants to prevent importing
   203  	// the i2c package
   204  	stepperMotor := 0
   205  	steps := 50
   206  	err := ada.Step(stepperMotor, steps, 1, 0)
   207  	gobottest.Assert(t, err, nil)
   208  }
   209  
   210  func TestAdafruitMotorHatDriverStepperDoubleStep(t *testing.T) {
   211  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   212  
   213  	gobottest.Assert(t, ada.Start(), nil)
   214  
   215  	// NOTE: not using the direction and style constants to prevent importing
   216  	// the i2c package
   217  	stepperMotor := 0
   218  	steps := 50
   219  	err := ada.Step(stepperMotor, steps, 1, 1)
   220  	gobottest.Assert(t, err, nil)
   221  }
   222  
   223  func TestAdafruitMotorHatDriverStepperInterleaveStep(t *testing.T) {
   224  	ada, _ := initTestAdafruitMotorHatDriverWithStubbedAdaptor()
   225  
   226  	gobottest.Assert(t, ada.Start(), nil)
   227  
   228  	// NOTE: not using the direction and style constants to prevent importing
   229  	// the i2c package
   230  	stepperMotor := 0
   231  	steps := 50
   232  	err := ada.Step(stepperMotor, steps, 1, 2)
   233  	gobottest.Assert(t, err, nil)
   234  }
   235  
   236  func TestAdafruitMotorHatDriverSetName(t *testing.T) {
   237  	d := initTestAdafruitMotorHatDriver()
   238  	d.SetName("TESTME")
   239  	gobottest.Assert(t, d.Name(), "TESTME")
   240  }
   241  
   242  func TestAdafruitMotorHatDriverOptions(t *testing.T) {
   243  	d := NewAdafruitMotorHatDriver(newI2cTestAdaptor(), WithBus(2))
   244  	gobottest.Assert(t, d.GetBusOrDefault(1), 2)
   245  }