gobot.io/x/gobot@v1.16.0/sysfs/i2c_device_test.go (about)

     1  package sysfs
     2  
     3  import (
     4  	"errors"
     5  	"os"
     6  	"syscall"
     7  	"testing"
     8  
     9  	"gobot.io/x/gobot/drivers/i2c"
    10  	"gobot.io/x/gobot/gobottest"
    11  )
    12  
    13  func TestNewI2cDeviceClose(t *testing.T) {
    14  	fs := NewMockFilesystem([]string{
    15  		"/dev/i2c-1",
    16  	})
    17  
    18  	SetFilesystem(fs)
    19  	SetSyscall(&MockSyscall{})
    20  
    21  	i, err := NewI2cDevice("/dev/i2c-1")
    22  	var _ i2c.I2cDevice = i
    23  
    24  	gobottest.Assert(t, err, nil)
    25  	gobottest.Assert(t, i.Close(), nil)
    26  }
    27  
    28  func TestNewI2cDeviceQueryFuncError(t *testing.T) {
    29  	fs := NewMockFilesystem([]string{
    30  		"/dev/i2c-1",
    31  	})
    32  	SetFilesystem(fs)
    33  
    34  	SetSyscall(&MockSyscall{
    35  		Impl: func(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
    36  			return 0, 0, 1
    37  		},
    38  	})
    39  
    40  	i, err := NewI2cDevice("/dev/i2c-1")
    41  	var _ i2c.I2cDevice = i
    42  
    43  	gobottest.Assert(t, err, errors.New("Querying functionality failed with syscall.Errno operation not permitted"))
    44  }
    45  
    46  func TestNewI2cDevice(t *testing.T) {
    47  	fs := NewMockFilesystem([]string{})
    48  	SetFilesystem(fs)
    49  	SetSyscall(&MockSyscall{})
    50  
    51  	i, err := NewI2cDevice(os.DevNull)
    52  	gobottest.Assert(t, err.Error(), " : /dev/null: No such file.")
    53  
    54  	fs = NewMockFilesystem([]string{
    55  		"/dev/i2c-1",
    56  	})
    57  	SetFilesystem(fs)
    58  
    59  	i, err = NewI2cDevice("/dev/i2c-1")
    60  	gobottest.Assert(t, err, nil)
    61  
    62  	SetSyscall(&MockSyscall{})
    63  
    64  	i, err = NewI2cDevice("/dev/i2c-1")
    65  	var _ i2c.I2cDevice = i
    66  
    67  	gobottest.Assert(t, err, nil)
    68  
    69  	gobottest.Assert(t, i.SetAddress(0xff), nil)
    70  
    71  	buf := []byte{0x01, 0x02, 0x03}
    72  
    73  	n, err := i.Write(buf)
    74  
    75  	gobottest.Assert(t, n, len(buf))
    76  	gobottest.Assert(t, err, nil)
    77  
    78  	buf = make([]byte, 4)
    79  
    80  	n, err = i.Read(buf)
    81  
    82  	gobottest.Assert(t, n, 3)
    83  	gobottest.Assert(t, err, nil)
    84  }
    85  
    86  func TestNewI2cDeviceReadByte(t *testing.T) {
    87  	fs := NewMockFilesystem([]string{
    88  		"/dev/i2c-1",
    89  	})
    90  	SetFilesystem(fs)
    91  
    92  	i, err := NewI2cDevice("/dev/i2c-1")
    93  	var _ i2c.I2cDevice = i
    94  
    95  	gobottest.Assert(t, err, nil)
    96  
    97  	i.SetAddress(0xff)
    98  	i.funcs = I2C_FUNC_SMBUS_READ_BYTE
    99  
   100  	val, e := i.ReadByte()
   101  	gobottest.Assert(t, val, byte(0))
   102  	gobottest.Assert(t, e, nil)
   103  }
   104  
   105  func TestNewI2cDeviceReadByteError(t *testing.T) {
   106  	fs := NewMockFilesystem([]string{
   107  		"/dev/i2c-1",
   108  	})
   109  	SetFilesystem(fs)
   110  
   111  	i, err := NewI2cDevice("/dev/i2c-1")
   112  	var _ i2c.I2cDevice = i
   113  
   114  	gobottest.Assert(t, err, nil)
   115  
   116  	SetSyscall(&MockSyscall{
   117  		Impl: func(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
   118  			return 0, 0, 1
   119  		},
   120  	})
   121  
   122  	i.SetAddress(0xff)
   123  	i.funcs = I2C_FUNC_SMBUS_READ_BYTE
   124  
   125  	_, e := i.ReadByte()
   126  	gobottest.Refute(t, e, nil)
   127  }
   128  
   129  func TestNewI2cDeviceReadByteNotSupported(t *testing.T) {
   130  	SetSyscall(&MockSyscall{})
   131  	i, err := NewI2cDevice("/dev/i2c-1")
   132  	var _ i2c.I2cDevice = i
   133  
   134  	gobottest.Assert(t, err, nil)
   135  
   136  	i.SetAddress(0xff)
   137  
   138  	_, err = i.ReadByte()
   139  	gobottest.Assert(t, err.Error(), "SMBus read byte not supported")
   140  }
   141  
   142  func TestNewI2cDeviceWriteByte(t *testing.T) {
   143  	fs := NewMockFilesystem([]string{
   144  		"/dev/i2c-1",
   145  	})
   146  	SetFilesystem(fs)
   147  
   148  	i, err := NewI2cDevice("/dev/i2c-1")
   149  	var _ i2c.I2cDevice = i
   150  
   151  	gobottest.Assert(t, err, nil)
   152  
   153  	i.SetAddress(0xff)
   154  	i.funcs = I2C_FUNC_SMBUS_WRITE_BYTE
   155  
   156  	e := i.WriteByte(0x01)
   157  	gobottest.Assert(t, e, nil)
   158  }
   159  
   160  func TestNewI2cDeviceWriteByteNotSupported(t *testing.T) {
   161  	SetSyscall(&MockSyscall{})
   162  	i, err := NewI2cDevice("/dev/i2c-1")
   163  	var _ i2c.I2cDevice = i
   164  
   165  	gobottest.Assert(t, err, nil)
   166  
   167  	i.SetAddress(0xff)
   168  
   169  	err = i.WriteByte(0x01)
   170  	gobottest.Assert(t, err.Error(), "SMBus write byte not supported")
   171  }
   172  
   173  func TestNewI2cDeviceReadByteData(t *testing.T) {
   174  	fs := NewMockFilesystem([]string{
   175  		"/dev/i2c-1",
   176  	})
   177  	SetFilesystem(fs)
   178  
   179  	i, err := NewI2cDevice("/dev/i2c-1")
   180  	var _ i2c.I2cDevice = i
   181  
   182  	gobottest.Assert(t, err, nil)
   183  
   184  	i.SetAddress(0xff)
   185  	i.funcs = I2C_FUNC_SMBUS_READ_BYTE_DATA
   186  
   187  	v, e := i.ReadByteData(0x01)
   188  	gobottest.Assert(t, v, byte(0))
   189  	gobottest.Assert(t, e, nil)
   190  }
   191  
   192  func TestNewI2cDeviceReadByteDataNotSupported(t *testing.T) {
   193  	SetSyscall(&MockSyscall{})
   194  	i, err := NewI2cDevice("/dev/i2c-1")
   195  	var _ i2c.I2cDevice = i
   196  
   197  	gobottest.Assert(t, err, nil)
   198  
   199  	i.SetAddress(0xff)
   200  
   201  	_, err = i.ReadByteData(0x01)
   202  	gobottest.Assert(t, err.Error(), "SMBus read byte data not supported")
   203  }
   204  
   205  func TestNewI2cDeviceWriteByteData(t *testing.T) {
   206  	fs := NewMockFilesystem([]string{
   207  		"/dev/i2c-1",
   208  	})
   209  	SetFilesystem(fs)
   210  
   211  	i, err := NewI2cDevice("/dev/i2c-1")
   212  	var _ i2c.I2cDevice = i
   213  
   214  	gobottest.Assert(t, err, nil)
   215  
   216  	i.SetAddress(0xff)
   217  	i.funcs = I2C_FUNC_SMBUS_WRITE_BYTE_DATA
   218  
   219  	e := i.WriteByteData(0x01, 0x02)
   220  	gobottest.Assert(t, e, nil)
   221  }
   222  
   223  func TestNewI2cDeviceWriteByteDataNotSupported(t *testing.T) {
   224  	SetSyscall(&MockSyscall{})
   225  	i, err := NewI2cDevice("/dev/i2c-1")
   226  	var _ i2c.I2cDevice = i
   227  
   228  	gobottest.Assert(t, err, nil)
   229  
   230  	i.SetAddress(0xff)
   231  
   232  	err = i.WriteByteData(0x01, 0x01)
   233  	gobottest.Assert(t, err.Error(), "SMBus write byte data not supported")
   234  }
   235  
   236  func TestNewI2cDeviceReadWordData(t *testing.T) {
   237  	fs := NewMockFilesystem([]string{
   238  		"/dev/i2c-1",
   239  	})
   240  	SetFilesystem(fs)
   241  
   242  	i, err := NewI2cDevice("/dev/i2c-1")
   243  	var _ i2c.I2cDevice = i
   244  
   245  	gobottest.Assert(t, err, nil)
   246  
   247  	i.SetAddress(0xff)
   248  	i.funcs = I2C_FUNC_SMBUS_READ_WORD_DATA
   249  
   250  	v, e := i.ReadWordData(0x01)
   251  	gobottest.Assert(t, v, uint16(0))
   252  	gobottest.Assert(t, e, nil)
   253  }
   254  
   255  func TestNewI2cDeviceReadWordDataNotSupported(t *testing.T) {
   256  	SetSyscall(&MockSyscall{})
   257  	i, err := NewI2cDevice("/dev/i2c-1")
   258  	var _ i2c.I2cDevice = i
   259  
   260  	gobottest.Assert(t, err, nil)
   261  
   262  	i.SetAddress(0xff)
   263  
   264  	_, err = i.ReadWordData(0x01)
   265  	gobottest.Assert(t, err.Error(), "SMBus read word data not supported")
   266  }
   267  
   268  func TestNewI2cDeviceWriteWordData(t *testing.T) {
   269  	fs := NewMockFilesystem([]string{
   270  		"/dev/i2c-1",
   271  	})
   272  	SetFilesystem(fs)
   273  
   274  	i, err := NewI2cDevice("/dev/i2c-1")
   275  	var _ i2c.I2cDevice = i
   276  
   277  	gobottest.Assert(t, err, nil)
   278  
   279  	i.SetAddress(0xff)
   280  	i.funcs = I2C_FUNC_SMBUS_WRITE_WORD_DATA
   281  
   282  	e := i.WriteWordData(0x01, 0x0102)
   283  	gobottest.Assert(t, e, nil)
   284  }
   285  
   286  func TestNewI2cDeviceWriteWordDataNotSupported(t *testing.T) {
   287  	SetSyscall(&MockSyscall{})
   288  	i, err := NewI2cDevice("/dev/i2c-1")
   289  	var _ i2c.I2cDevice = i
   290  
   291  	gobottest.Assert(t, err, nil)
   292  
   293  	i.SetAddress(0xff)
   294  
   295  	err = i.WriteWordData(0x01, 0x01)
   296  	gobottest.Assert(t, err.Error(), "SMBus write word data not supported")
   297  }
   298  
   299  func TestNewI2cDeviceWriteBlockData(t *testing.T) {
   300  	fs := NewMockFilesystem([]string{
   301  		"/dev/i2c-1",
   302  	})
   303  	SetFilesystem(fs)
   304  
   305  	i, err := NewI2cDevice("/dev/i2c-1")
   306  	var _ i2c.I2cDevice = i
   307  
   308  	gobottest.Assert(t, err, nil)
   309  
   310  	i.SetAddress(0xff)
   311  
   312  	e := i.WriteBlockData(0x01, []byte{0x01, 0x02, 0x03})
   313  	gobottest.Assert(t, e, nil)
   314  }
   315  
   316  func TestNewI2cDeviceWriteBlockDataTooMuch(t *testing.T) {
   317  	fs := NewMockFilesystem([]string{
   318  		"/dev/i2c-1",
   319  	})
   320  	SetFilesystem(fs)
   321  
   322  	i, err := NewI2cDevice("/dev/i2c-1")
   323  	var _ i2c.I2cDevice = i
   324  
   325  	gobottest.Assert(t, err, nil)
   326  
   327  	i.SetAddress(0xff)
   328  
   329  	var data []byte
   330  	data = make([]byte, 33)
   331  	e := i.WriteBlockData(0x01, data)
   332  	gobottest.Assert(t, e, errors.New("Writing blocks larger than 32 bytes (33) not supported"))
   333  }
   334  
   335  func TestNewI2cDeviceWrite(t *testing.T) {
   336  	SetSyscall(&MockSyscall{})
   337  	i, err := NewI2cDevice("/dev/i2c-1")
   338  	var _ i2c.I2cDevice = i
   339  
   340  	gobottest.Assert(t, err, nil)
   341  
   342  	i.SetAddress(0xff)
   343  	buf := []byte{0x01, 0x02, 0x03}
   344  
   345  	n, err := i.Write(buf)
   346  
   347  	gobottest.Assert(t, n, len(buf))
   348  	gobottest.Assert(t, err, nil)
   349  }