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