gobot.io/x/gobot@v1.16.0/drivers/i2c/bme280_driver_test.go (about)

     1  package i2c
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"testing"
     7  
     8  	"gobot.io/x/gobot"
     9  	"gobot.io/x/gobot/gobottest"
    10  )
    11  
    12  var _ gobot.Driver = (*BME280Driver)(nil)
    13  
    14  // --------- HELPERS
    15  func initTestBME280Driver() (driver *BME280Driver) {
    16  	driver, _ = initTestBME280DriverWithStubbedAdaptor()
    17  	return
    18  }
    19  
    20  func initTestBME280DriverWithStubbedAdaptor() (*BME280Driver, *i2cTestAdaptor) {
    21  	adaptor := newI2cTestAdaptor()
    22  	return NewBME280Driver(adaptor), adaptor
    23  }
    24  
    25  // --------- TESTS
    26  
    27  func TestNewBME280Driver(t *testing.T) {
    28  	// Does it return a pointer to an instance of BME280Driver?
    29  	var bme280 interface{} = NewBME280Driver(newI2cTestAdaptor())
    30  	_, ok := bme280.(*BME280Driver)
    31  	if !ok {
    32  		t.Errorf("NewBME280Driver() should have returned a *BME280Driver")
    33  	}
    34  }
    35  
    36  func TestBME280Driver(t *testing.T) {
    37  	bme280 := initTestBME280Driver()
    38  	gobottest.Refute(t, bme280.Connection(), nil)
    39  }
    40  
    41  func TestBME280DriverStart(t *testing.T) {
    42  	bme280, adaptor := initTestBME280DriverWithStubbedAdaptor()
    43  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
    44  		// Simulate returning a single byte for the
    45  		// ReadByteData(bmp280RegisterControl) call in Start()
    46  		return 1, nil
    47  	}
    48  	gobottest.Assert(t, bme280.Start(), nil)
    49  }
    50  
    51  func TestBME280StartConnectError(t *testing.T) {
    52  	d, adaptor := initTestBME280DriverWithStubbedAdaptor()
    53  	adaptor.Testi2cConnectErr(true)
    54  	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
    55  }
    56  
    57  func TestBME280DriverStartWriteError(t *testing.T) {
    58  	bme280, adaptor := initTestBME280DriverWithStubbedAdaptor()
    59  	adaptor.i2cWriteImpl = func([]byte) (int, error) {
    60  		return 0, errors.New("write error")
    61  	}
    62  	gobottest.Assert(t, bme280.Start(), errors.New("write error"))
    63  }
    64  
    65  func TestBME280DriverStartReadError(t *testing.T) {
    66  	bme280, adaptor := initTestBME280DriverWithStubbedAdaptor()
    67  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
    68  		return 0, errors.New("read error")
    69  	}
    70  	gobottest.Assert(t, bme280.Start(), errors.New("read error"))
    71  }
    72  
    73  func TestBME280DriverHalt(t *testing.T) {
    74  	bme280 := initTestBME280Driver()
    75  
    76  	gobottest.Assert(t, bme280.Halt(), nil)
    77  }
    78  
    79  func TestBME280DriverMeasurements(t *testing.T) {
    80  	bme280, adaptor := initTestBME280DriverWithStubbedAdaptor()
    81  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
    82  		buf := new(bytes.Buffer)
    83  		// Values produced by dumping data from actual sensor
    84  		if adaptor.written[len(adaptor.written)-1] == bmp280RegisterCalib00 {
    85  			buf.Write([]byte{126, 109, 214, 102, 50, 0, 54, 149, 220, 213, 208, 11, 64, 30, 166, 255, 249, 255, 172, 38, 10, 216, 189, 16})
    86  		} else if adaptor.written[len(adaptor.written)-1] == bme280RegisterCalibDigH1 {
    87  			buf.Write([]byte{75})
    88  		} else if adaptor.written[len(adaptor.written)-1] == bmp280RegisterTempData {
    89  			buf.Write([]byte{129, 0, 0})
    90  		} else if adaptor.written[len(adaptor.written)-1] == bme280RegisterCalibDigH2LSB {
    91  			buf.Write([]byte{112, 1, 0, 19, 1, 0, 30})
    92  		} else if adaptor.written[len(adaptor.written)-1] == bme280RegisterHumidityMSB {
    93  			buf.Write([]byte{111, 83})
    94  		}
    95  		copy(b, buf.Bytes())
    96  		return buf.Len(), nil
    97  	}
    98  	bme280.Start()
    99  	hum, err := bme280.Humidity()
   100  	gobottest.Assert(t, err, nil)
   101  	gobottest.Assert(t, hum, float32(51.20179))
   102  }
   103  
   104  func TestBME280DriverInitH1Error(t *testing.T) {
   105  	bme280, adaptor := initTestBME280DriverWithStubbedAdaptor()
   106  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
   107  		buf := new(bytes.Buffer)
   108  		// Values produced by dumping data from actual sensor
   109  		if adaptor.written[len(adaptor.written)-1] == bmp280RegisterCalib00 {
   110  			buf.Write([]byte{126, 109, 214, 102, 50, 0, 54, 149, 220, 213, 208, 11, 64, 30, 166, 255, 249, 255, 172, 38, 10, 216, 189, 16})
   111  		} else if adaptor.written[len(adaptor.written)-1] == bme280RegisterCalibDigH1 {
   112  			return 0, errors.New("h1 read error")
   113  		} else if adaptor.written[len(adaptor.written)-1] == bme280RegisterCalibDigH2LSB {
   114  			buf.Write([]byte{112, 1, 0, 19, 1, 0, 30})
   115  		}
   116  		copy(b, buf.Bytes())
   117  		return buf.Len(), nil
   118  	}
   119  
   120  	gobottest.Assert(t, bme280.Start(), errors.New("h1 read error"))
   121  }
   122  
   123  func TestBME280DriverInitH2Error(t *testing.T) {
   124  	bme280, adaptor := initTestBME280DriverWithStubbedAdaptor()
   125  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
   126  		buf := new(bytes.Buffer)
   127  		// Values produced by dumping data from actual sensor
   128  		if adaptor.written[len(adaptor.written)-1] == bmp280RegisterCalib00 {
   129  			buf.Write([]byte{126, 109, 214, 102, 50, 0, 54, 149, 220, 213, 208, 11, 64, 30, 166, 255, 249, 255, 172, 38, 10, 216, 189, 16})
   130  		} else if adaptor.written[len(adaptor.written)-1] == bme280RegisterCalibDigH1 {
   131  			buf.Write([]byte{75})
   132  		} else if adaptor.written[len(adaptor.written)-1] == bme280RegisterCalibDigH2LSB {
   133  			return 0, errors.New("h2 read error")
   134  		}
   135  		copy(b, buf.Bytes())
   136  		return buf.Len(), nil
   137  	}
   138  
   139  	gobottest.Assert(t, bme280.Start(), errors.New("h2 read error"))
   140  }
   141  
   142  func TestBME280DriverHumidityWriteError(t *testing.T) {
   143  	bme280, adaptor := initTestBME280DriverWithStubbedAdaptor()
   144  	bme280.Start()
   145  
   146  	adaptor.i2cWriteImpl = func([]byte) (int, error) {
   147  		return 0, errors.New("write error")
   148  	}
   149  	hum, err := bme280.Humidity()
   150  	gobottest.Assert(t, err, errors.New("write error"))
   151  	gobottest.Assert(t, hum, float32(0.0))
   152  }
   153  
   154  func TestBME280DriverHumidityReadError(t *testing.T) {
   155  	bme280, adaptor := initTestBME280DriverWithStubbedAdaptor()
   156  	bme280.Start()
   157  
   158  	adaptor.i2cReadImpl = func([]byte) (int, error) {
   159  		return 0, errors.New("read error")
   160  	}
   161  	hum, err := bme280.Humidity()
   162  	gobottest.Assert(t, err, errors.New("read error"))
   163  	gobottest.Assert(t, hum, float32(0.0))
   164  }
   165  
   166  func TestBME280DriverHumidityNotEnabled(t *testing.T) {
   167  	bme280, adaptor := initTestBME280DriverWithStubbedAdaptor()
   168  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
   169  		buf := new(bytes.Buffer)
   170  		// Values produced by dumping data from actual sensor
   171  		if adaptor.written[len(adaptor.written)-1] == bmp280RegisterCalib00 {
   172  			buf.Write([]byte{126, 109, 214, 102, 50, 0, 54, 149, 220, 213, 208, 11, 64, 30, 166, 255, 249, 255, 172, 38, 10, 216, 189, 16})
   173  		} else if adaptor.written[len(adaptor.written)-1] == bme280RegisterCalibDigH1 {
   174  			buf.Write([]byte{75})
   175  		} else if adaptor.written[len(adaptor.written)-1] == bmp280RegisterTempData {
   176  			buf.Write([]byte{129, 0, 0})
   177  		} else if adaptor.written[len(adaptor.written)-1] == bme280RegisterCalibDigH2LSB {
   178  			buf.Write([]byte{112, 1, 0, 19, 1, 0, 30})
   179  		} else if adaptor.written[len(adaptor.written)-1] == bme280RegisterHumidityMSB {
   180  			buf.Write([]byte{0x80, 0x00})
   181  		}
   182  		copy(b, buf.Bytes())
   183  		return buf.Len(), nil
   184  	}
   185  	bme280.Start()
   186  	hum, err := bme280.Humidity()
   187  	gobottest.Assert(t, err, errors.New("Humidity disabled"))
   188  	gobottest.Assert(t, hum, float32(0.0))
   189  }
   190  
   191  func TestBME280DriverSetName(t *testing.T) {
   192  	b := initTestBME280Driver()
   193  	b.SetName("TESTME")
   194  	gobottest.Assert(t, b.Name(), "TESTME")
   195  }
   196  
   197  func TestBME280DriverOptions(t *testing.T) {
   198  	b := NewBME280Driver(newI2cTestAdaptor(), WithBus(2))
   199  	gobottest.Assert(t, b.GetBusOrDefault(1), 2)
   200  }