gobot.io/x/gobot@v1.16.0/drivers/gpio/hd44780_driver_test.go (about)

     1  package gpio
     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 = (*HD44780Driver)(nil)
    13  
    14  // --------- HELPERS
    15  func initTestHD44780Driver() (driver *HD44780Driver) {
    16  	driver, _ = initTestHD44780Driver4BitModeWithStubbedAdaptor()
    17  	return
    18  }
    19  
    20  func initTestHD44780Driver4BitModeWithStubbedAdaptor() (*HD44780Driver, *gpioTestAdaptor) {
    21  	adaptor := newGpioTestAdaptor()
    22  	dataPins := HD44780DataPin{
    23  		D4: "22",
    24  		D5: "18",
    25  		D6: "16",
    26  		D7: "12",
    27  	}
    28  
    29  	return NewHD44780Driver(adaptor, 2, 16, HD44780_4BITMODE, "13", "15", dataPins), adaptor
    30  }
    31  
    32  func initTestHD44780Driver8BitModeWithStubbedAdaptor() (*HD44780Driver, *gpioTestAdaptor) {
    33  	adaptor := newGpioTestAdaptor()
    34  	dataPins := HD44780DataPin{
    35  		D0: "31",
    36  		D1: "33",
    37  		D2: "35",
    38  		D3: "37",
    39  		D4: "22",
    40  		D5: "18",
    41  		D6: "16",
    42  		D7: "12",
    43  	}
    44  
    45  	return NewHD44780Driver(adaptor, 2, 16, HD44780_8BITMODE, "13", "15", dataPins), adaptor
    46  }
    47  
    48  // --------- TESTS
    49  func TestHD44780Driver(t *testing.T) {
    50  	var a interface{} = initTestHD44780Driver()
    51  	_, ok := a.(*HD44780Driver)
    52  	if !ok {
    53  		t.Errorf("NewHD44780Driver() should have returned a *HD44780Driver")
    54  	}
    55  }
    56  
    57  func TestHD44780DriverHalt(t *testing.T) {
    58  	d := initTestHD44780Driver()
    59  	d.Start()
    60  	gobottest.Assert(t, d.Halt(), nil)
    61  }
    62  
    63  func TestHD44780DriverDefaultName(t *testing.T) {
    64  	d := initTestHD44780Driver()
    65  	gobottest.Assert(t, strings.HasPrefix(d.Name(), "HD44780Driver"), true)
    66  }
    67  
    68  func TestHD44780DriverSetName(t *testing.T) {
    69  	d := initTestHD44780Driver()
    70  	d.SetName("my driver")
    71  	gobottest.Assert(t, d.Name(), "my driver")
    72  }
    73  
    74  func TestHD44780DriverStart(t *testing.T) {
    75  	d := initTestHD44780Driver()
    76  	gobottest.Assert(t, d.Start(), nil)
    77  }
    78  
    79  func TestHD44780DriverStartError(t *testing.T) {
    80  	a := newGpioTestAdaptor()
    81  
    82  	var pins HD44780DataPin
    83  	var d *HD44780Driver
    84  
    85  	pins = HD44780DataPin{
    86  		D4: "22",
    87  		D5: "18",
    88  		D6: "16",
    89  		D7: "",
    90  	}
    91  	d = NewHD44780Driver(a, 2, 16, HD44780_4BITMODE, "13", "15", pins)
    92  	gobottest.Assert(t, d.Start(), errors.New("Initialization error"))
    93  
    94  	pins = HD44780DataPin{
    95  		D0: "31",
    96  		D1: "33",
    97  		D2: "35",
    98  		D3: "37",
    99  		D4: "22",
   100  		D5: "18",
   101  		D6: "16",
   102  		D7: "",
   103  	}
   104  	d = NewHD44780Driver(a, 2, 16, HD44780_8BITMODE, "13", "15", pins)
   105  	gobottest.Assert(t, d.Start(), errors.New("Initialization error"))
   106  }
   107  
   108  func TestHD44780DriverWrite(t *testing.T) {
   109  	var d *HD44780Driver
   110  
   111  	d, _ = initTestHD44780Driver4BitModeWithStubbedAdaptor()
   112  	d.Start()
   113  	gobottest.Assert(t, d.Write("hello gobot"), nil)
   114  
   115  	d, _ = initTestHD44780Driver8BitModeWithStubbedAdaptor()
   116  	d.Start()
   117  	gobottest.Assert(t, d.Write("hello gobot"), nil)
   118  }
   119  
   120  func TestHD44780DriverWriteError(t *testing.T) {
   121  	var d *HD44780Driver
   122  	var a *gpioTestAdaptor
   123  
   124  	d, a = initTestHD44780Driver4BitModeWithStubbedAdaptor()
   125  	a.testAdaptorDigitalWrite = func(string, byte) (err error) {
   126  		return errors.New("write error")
   127  	}
   128  	d.Start()
   129  	gobottest.Assert(t, d.Write("hello gobot"), errors.New("write error"))
   130  
   131  	d, a = initTestHD44780Driver8BitModeWithStubbedAdaptor()
   132  	a.testAdaptorDigitalWrite = func(string, byte) (err error) {
   133  		return errors.New("write error")
   134  	}
   135  	d.Start()
   136  	gobottest.Assert(t, d.Write("hello gobot"), errors.New("write error"))
   137  }
   138  
   139  func TestHD44780DriverClear(t *testing.T) {
   140  	d := initTestHD44780Driver()
   141  	d.Start()
   142  	gobottest.Assert(t, d.Clear(), nil)
   143  }
   144  
   145  func TestHD44780DriverHome(t *testing.T) {
   146  	d := initTestHD44780Driver()
   147  	d.Start()
   148  	gobottest.Assert(t, d.Home(), nil)
   149  }
   150  
   151  func TestHD44780DriverSetCursor(t *testing.T) {
   152  	d := initTestHD44780Driver()
   153  	d.Start()
   154  	gobottest.Assert(t, d.SetCursor(0, 3), nil)
   155  }
   156  
   157  func TestHD44780DriverSetCursorInvalid(t *testing.T) {
   158  	d := initTestHD44780Driver()
   159  	d.Start()
   160  	gobottest.Assert(t, d.SetCursor(-1, 3), errors.New("Invalid position value (-1, 3), range (1, 15)"))
   161  	gobottest.Assert(t, d.SetCursor(2, 3), errors.New("Invalid position value (2, 3), range (1, 15)"))
   162  	gobottest.Assert(t, d.SetCursor(0, -1), errors.New("Invalid position value (0, -1), range (1, 15)"))
   163  	gobottest.Assert(t, d.SetCursor(0, 16), errors.New("Invalid position value (0, 16), range (1, 15)"))
   164  }
   165  
   166  func TestHD44780DriverDisplayOn(t *testing.T) {
   167  	d := initTestHD44780Driver()
   168  	d.Start()
   169  	gobottest.Assert(t, d.Display(true), nil)
   170  }
   171  
   172  func TestHD44780DriverDisplayOff(t *testing.T) {
   173  	d := initTestHD44780Driver()
   174  	d.Start()
   175  	gobottest.Assert(t, d.Display(false), nil)
   176  }
   177  
   178  func TestHD44780DriverCursorOn(t *testing.T) {
   179  	d := initTestHD44780Driver()
   180  	d.Start()
   181  	gobottest.Assert(t, d.Cursor(true), nil)
   182  }
   183  
   184  func TestHD44780DriverCursorOff(t *testing.T) {
   185  	d := initTestHD44780Driver()
   186  	d.Start()
   187  	gobottest.Assert(t, d.Cursor(false), nil)
   188  }
   189  
   190  func TestHD44780DriverBlinkOn(t *testing.T) {
   191  	d := initTestHD44780Driver()
   192  	d.Start()
   193  	gobottest.Assert(t, d.Blink(true), nil)
   194  }
   195  
   196  func TestHD44780DriverBlinkOff(t *testing.T) {
   197  	d := initTestHD44780Driver()
   198  	d.Start()
   199  	gobottest.Assert(t, d.Blink(false), nil)
   200  }
   201  
   202  func TestHD44780DriverScrollLeft(t *testing.T) {
   203  	d := initTestHD44780Driver()
   204  	d.Start()
   205  	gobottest.Assert(t, d.ScrollLeft(), nil)
   206  }
   207  
   208  func TestHD44780DriverScrollRight(t *testing.T) {
   209  	d := initTestHD44780Driver()
   210  	d.Start()
   211  	gobottest.Assert(t, d.ScrollRight(), nil)
   212  }
   213  
   214  func TestHD44780DriverLeftToRight(t *testing.T) {
   215  	d := initTestHD44780Driver()
   216  	d.Start()
   217  	gobottest.Assert(t, d.LeftToRight(), nil)
   218  }
   219  
   220  func TestHD44780DriverRightToLeft(t *testing.T) {
   221  	d := initTestHD44780Driver()
   222  	d.Start()
   223  	gobottest.Assert(t, d.RightToLeft(), nil)
   224  }
   225  
   226  func TestHD44780DriverSendCommand(t *testing.T) {
   227  	d := initTestHD44780Driver()
   228  	d.Start()
   229  	gobottest.Assert(t, d.SendCommand(0x33), nil)
   230  }
   231  
   232  func TestHD44780DriverWriteChar(t *testing.T) {
   233  	d := initTestHD44780Driver()
   234  	d.Start()
   235  	gobottest.Assert(t, d.WriteChar(0x41), nil)
   236  }
   237  
   238  func TestHD44780DriverCreateChar(t *testing.T) {
   239  	d := initTestHD44780Driver()
   240  	d.Start()
   241  	charMap := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
   242  	gobottest.Assert(t, d.CreateChar(0, charMap), nil)
   243  }
   244  
   245  func TestHD44780DriverCreateCharError(t *testing.T) {
   246  	d := initTestHD44780Driver()
   247  	d.Start()
   248  	charMap := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
   249  	gobottest.Assert(t, d.CreateChar(8, charMap), errors.New("can't set a custom character at a position greater than 7"))
   250  }