gobot.io/x/gobot@v1.16.0/platforms/neurosky/neurosky_driver_test.go (about)

     1  package neurosky
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"io"
     7  	"strings"
     8  	"testing"
     9  	"time"
    10  
    11  	"gobot.io/x/gobot"
    12  	"gobot.io/x/gobot/gobottest"
    13  )
    14  
    15  var _ gobot.Driver = (*Driver)(nil)
    16  
    17  func initTestNeuroskyDriver() *Driver {
    18  	a := NewAdaptor("/dev/null")
    19  	a.connect = func(n *Adaptor) (io.ReadWriteCloser, error) {
    20  		return &NullReadWriteCloser{}, nil
    21  	}
    22  	a.Connect()
    23  	return NewDriver(a)
    24  }
    25  
    26  func TestNeuroskyDriver(t *testing.T) {
    27  	d := initTestNeuroskyDriver()
    28  	gobottest.Refute(t, d.Connection(), nil)
    29  }
    30  
    31  func TestNeuroskyDriverName(t *testing.T) {
    32  	d := initTestNeuroskyDriver()
    33  	gobottest.Assert(t, strings.HasPrefix(d.Name(), "Neurosky"), true)
    34  	d.SetName("NewName")
    35  	gobottest.Assert(t, d.Name(), "NewName")
    36  }
    37  
    38  func TestNeuroskyDriverStart(t *testing.T) {
    39  	sem := make(chan bool, 0)
    40  
    41  	rwc := &NullReadWriteCloser{}
    42  	a := NewAdaptor("/dev/null")
    43  	a.connect = func(n *Adaptor) (io.ReadWriteCloser, error) {
    44  		return rwc, nil
    45  	}
    46  	a.Connect()
    47  
    48  	d := NewDriver(a)
    49  	e := errors.New("read error")
    50  	d.Once(d.Event(Error), func(data interface{}) {
    51  		gobottest.Assert(t, data.(error), e)
    52  		sem <- true
    53  	})
    54  
    55  	gobottest.Assert(t, d.Start(), nil)
    56  
    57  	time.Sleep(50 * time.Millisecond)
    58  	rwc.ReadError(e)
    59  
    60  	select {
    61  	case <-sem:
    62  	case <-time.After(100 * time.Millisecond):
    63  		{
    64  			t.Errorf("error was not emitted")
    65  		}
    66  
    67  	}
    68  }
    69  
    70  func TestNeuroskyDriverHalt(t *testing.T) {
    71  	d := initTestNeuroskyDriver()
    72  	gobottest.Assert(t, d.Halt(), nil)
    73  }
    74  
    75  func TestNeuroskyDriverParse(t *testing.T) {
    76  	sem := make(chan bool)
    77  	d := initTestNeuroskyDriver()
    78  
    79  	// CodeEx
    80  	go func() {
    81  		time.Sleep(5 * time.Millisecond)
    82  		d.parse(bytes.NewBuffer([]byte{0xAA, 0xAA, 1, 0x55, 0x00}))
    83  	}()
    84  
    85  	d.On(d.Event(Extended), func(data interface{}) {
    86  		sem <- true
    87  	})
    88  
    89  	select {
    90  	case <-sem:
    91  	case <-time.After(100 * time.Millisecond):
    92  		t.Errorf("Event \"extended\" was not published")
    93  	}
    94  
    95  	// CodeSignalQuality
    96  	go func() {
    97  		time.Sleep(5 * time.Millisecond)
    98  		d.parse(bytes.NewBuffer([]byte{0xAA, 0xAA, 2, 0x02, 100, 0x00}))
    99  	}()
   100  
   101  	d.On(d.Event(Signal), func(data interface{}) {
   102  		gobottest.Assert(t, data.(byte), byte(100))
   103  		sem <- true
   104  	})
   105  
   106  	<-sem
   107  
   108  	// CodeAttention
   109  	go func() {
   110  		time.Sleep(5 * time.Millisecond)
   111  		d.parse(bytes.NewBuffer([]byte{0xAA, 0xAA, 2, 0x04, 40, 0x00}))
   112  	}()
   113  
   114  	d.On(d.Event(Attention), func(data interface{}) {
   115  		gobottest.Assert(t, data.(byte), byte(40))
   116  		sem <- true
   117  	})
   118  
   119  	<-sem
   120  
   121  	// CodeMeditation
   122  	go func() {
   123  		time.Sleep(5 * time.Millisecond)
   124  		d.parse(bytes.NewBuffer([]byte{0xAA, 0xAA, 2, 0x05, 60, 0x00}))
   125  	}()
   126  
   127  	d.On(d.Event(Meditation), func(data interface{}) {
   128  		gobottest.Assert(t, data.(byte), byte(60))
   129  		sem <- true
   130  	})
   131  
   132  	<-sem
   133  
   134  	// CodeBlink
   135  	go func() {
   136  		time.Sleep(5 * time.Millisecond)
   137  		d.parse(bytes.NewBuffer([]byte{0xAA, 0xAA, 2, 0x16, 150, 0x00}))
   138  	}()
   139  
   140  	d.On(d.Event(Blink), func(data interface{}) {
   141  		gobottest.Assert(t, data.(byte), byte(150))
   142  		sem <- true
   143  	})
   144  
   145  	<-sem
   146  
   147  	// CodeWave
   148  	go func() {
   149  		time.Sleep(5 * time.Millisecond)
   150  		d.parse(bytes.NewBuffer([]byte{0xAA, 0xAA, 4, 0x80, 0x00, 0x40, 0x11, 0x00}))
   151  	}()
   152  
   153  	d.On(d.Event(Wave), func(data interface{}) {
   154  		gobottest.Assert(t, data.(int16), int16(16401))
   155  		sem <- true
   156  	})
   157  
   158  	<-sem
   159  
   160  	// CodeAsicEEG
   161  	go func() {
   162  		time.Sleep(5 * time.Millisecond)
   163  		d.parse(bytes.NewBuffer([]byte{0xAA, 0xAA, 30, 0x83, 24, 1, 121, 89, 0,
   164  			97, 26, 0, 30, 189, 0, 57, 1, 0, 62, 160, 0, 31, 127, 0, 18, 207, 0, 13,
   165  			108, 0x00}))
   166  	}()
   167  
   168  	d.On(d.Event(EEG), func(data interface{}) {
   169  		gobottest.Assert(t,
   170  			data.(EEGData),
   171  			EEGData{
   172  				Delta:    1573241,
   173  				Theta:    5832801,
   174  				LoAlpha:  1703966,
   175  				HiAlpha:  12386361,
   176  				LoBeta:   65598,
   177  				HiBeta:   10485791,
   178  				LoGamma:  8323090,
   179  				MidGamma: 13565965,
   180  			})
   181  		sem <- true
   182  	})
   183  	<-sem
   184  }