gobot.io/x/gobot/v2@v2.1.0/drivers/aio/grove_drivers_test.go (about)

     1  package aio
     2  
     3  import (
     4  	"errors"
     5  	"reflect"
     6  	"sync/atomic"
     7  	"testing"
     8  	"time"
     9  
    10  	"gobot.io/x/gobot/v2"
    11  	"gobot.io/x/gobot/v2/gobottest"
    12  )
    13  
    14  type DriverAndPinner interface {
    15  	gobot.Driver
    16  	gobot.Pinner
    17  }
    18  
    19  type DriverAndEventer interface {
    20  	gobot.Driver
    21  	gobot.Eventer
    22  }
    23  
    24  func TestDriverDefaults(t *testing.T) {
    25  	testAdaptor := newAioTestAdaptor()
    26  	pin := "456"
    27  
    28  	drivers := []DriverAndPinner{
    29  		NewGroveSoundSensorDriver(testAdaptor, pin),
    30  		NewGroveLightSensorDriver(testAdaptor, pin),
    31  		NewGrovePiezoVibrationSensorDriver(testAdaptor, pin),
    32  		NewGroveRotaryDriver(testAdaptor, pin),
    33  	}
    34  
    35  	for _, driver := range drivers {
    36  		gobottest.Assert(t, driver.Connection(), testAdaptor)
    37  		gobottest.Assert(t, driver.Pin(), pin)
    38  	}
    39  }
    40  
    41  func TestAnalogDriverHalt(t *testing.T) {
    42  	testAdaptor := newAioTestAdaptor()
    43  	pin := "456"
    44  
    45  	drivers := []DriverAndEventer{
    46  		NewGroveSoundSensorDriver(testAdaptor, pin),
    47  		NewGroveLightSensorDriver(testAdaptor, pin),
    48  		NewGrovePiezoVibrationSensorDriver(testAdaptor, pin),
    49  		NewGroveRotaryDriver(testAdaptor, pin),
    50  	}
    51  
    52  	for _, driver := range drivers {
    53  		var callCount int32
    54  		testAdaptor.TestAdaptorAnalogRead(func() (int, error) {
    55  			atomic.AddInt32(&callCount, 1)
    56  			return 42, nil
    57  		})
    58  
    59  		// Start the driver and allow for multiple digital reads
    60  		driver.Start()
    61  		time.Sleep(20 * time.Millisecond)
    62  
    63  		driver.Halt()
    64  		lastCallCount := atomic.LoadInt32(&callCount)
    65  		// If driver was not halted, digital reads would still continue
    66  		time.Sleep(20 * time.Millisecond)
    67  		if atomic.LoadInt32(&callCount) != lastCallCount {
    68  			t.Errorf("AnalogRead was called after driver was halted")
    69  		}
    70  	}
    71  }
    72  
    73  func TestDriverPublishesError(t *testing.T) {
    74  	testAdaptor := newAioTestAdaptor()
    75  	pin := "456"
    76  
    77  	drivers := []DriverAndEventer{
    78  		NewGroveSoundSensorDriver(testAdaptor, pin),
    79  		NewGroveLightSensorDriver(testAdaptor, pin),
    80  		NewGrovePiezoVibrationSensorDriver(testAdaptor, pin),
    81  		NewGroveRotaryDriver(testAdaptor, pin),
    82  	}
    83  
    84  	for _, driver := range drivers {
    85  		sem := make(chan struct{}, 1)
    86  		// send error
    87  		returnErr := func() (val int, err error) {
    88  			err = errors.New("read error")
    89  			return
    90  		}
    91  		testAdaptor.TestAdaptorAnalogRead(returnErr)
    92  
    93  		gobottest.Assert(t, driver.Start(), nil)
    94  
    95  		// expect error
    96  		driver.Once(driver.Event(Error), func(data interface{}) {
    97  			gobottest.Assert(t, data.(error).Error(), "read error")
    98  			close(sem)
    99  		})
   100  
   101  		select {
   102  		case <-sem:
   103  		case <-time.After(time.Second):
   104  			t.Errorf("%s Event \"Error\" was not published", getType(driver))
   105  		}
   106  
   107  		// Cleanup
   108  		driver.Halt()
   109  	}
   110  }
   111  
   112  func getType(driver interface{}) string {
   113  	d := reflect.TypeOf(driver)
   114  
   115  	if d.Kind() == reflect.Ptr {
   116  		return d.Elem().Name()
   117  	}
   118  
   119  	return d.Name()
   120  }