Example #1
0
        public void ExceptionWorkTest()
        {
            var portMock = new Mock<IBinaryPort>();
            // выбрасываем исключение, например при чтении из закрытого порта
            portMock.Setup(foo => foo.ReadBytesBlock(1)).Throws<IOException>();
            var loggerStub = new LoggerStub();

            var target = new PortListener(portMock.Object, loggerStub);
            var syncEvent = new AutoResetEvent(false);
            EventHandler<ExceptionCoughtArgs> exceptionHandler = (sender, e) => syncEvent.Set();
            target.ExceptionCought += exceptionHandler;

            target.StartListen();
            if (!syncEvent.WaitOne(5000)) // ждем вызова обработчика
            {
                Assert.Fail("Таймаут ожидания исключения");
            }
            target.ExceptionCought -= exceptionHandler;

            // для примера: вызывающий код обработал исключение, открыл порт с валидными данными
            portMock.Setup(foo => foo.ReadBytesBlock(1)).Returns(new byte[] { 0xA });
            portMock.Setup(foo => foo.ReadBytesBlock(16)).Returns(new byte[] { 0, 0, 0, 0, 0, 0, 52, 64, 0, 0, 0, 0, 0, 192, 82, 192 });
            target.AccelDataReceived += (sender, args) => syncEvent.Set();
            target.StartListen(); // снова запускаем

            if (!syncEvent.WaitOne(5000)) // ждем вызова обработчика
            {
                Assert.Fail("Таймаут ожидания данных");
            }

            Assert.IsTrue(target.IsListen, "поток работает");
            target.StopListen();
        }
Example #2
0
        public void DataReceivingTest()
        {
            var portMock = new Mock<IBinaryPort>();
            portMock.Setup(foo => foo.ReadBytesBlock(1)).Returns(new byte[] {0xA}); // возвращаем сигнатуру
            // возвращаем тело пакета
            portMock.Setup(foo => foo.ReadBytesBlock(16)).Returns(new byte[]{0, 0, 0, 0, 0, 0, 52, 64, 0, 0, 0, 0, 0, 192, 82,192});
            var loggerStub = new LoggerStub();

            var target = new PortListener(portMock.Object, loggerStub);

            var expected = new AccelData(20.0, -75.0);
            var syncEvent = new AutoResetEvent(false);
            AccelData actual = null;

            target.AccelDataReceived += (sender, dataArgs) =>
                                       {
                                           syncEvent.Set();
                                           actual = dataArgs.Data;
                                       };

            target.StartListen();
            if (!syncEvent.WaitOne(5000)) // ждем события
            {
                Assert.Fail("Таймаут ожидания данных");
            }
            target.StopListen();

            Assert.AreEqual(expected.Ax, actual.Ax); // проверяем правильность разбора пакета
        }
Example #3
0
        public void ConstructorTest()
        {
            var portMock = new Mock<IBinaryPort>();
            var loggerStub = new LoggerStub();

            var target = new PortListener(portMock.Object, loggerStub);
            Assert.IsFalse(target.IsListen, "конструктор не запускает поток");
        }
        public void GetAccelDataByDateSpanTest()
        {
            _testDb.CreateDatabase();
            _testDb.InitTestSchema();
            _testDb.PopulateTestAccelData();
            string databaseFile = _testDbFile;
            ILogger logger = new LoggerStub();
            var target = new LocalDatabaseStorage(databaseFile, logger);
            target.Open();

            var actual = target.GetAccelDataByDateSpan(new DateTime(2012, 1, 1) - TimeSpan.FromDays(10), new DateTime(2012, 1, 1));

            Assert.AreEqual(2, actual.Count);

            target.Close();
        }
        public void GetAccelDataTest()
        {
            _testDb.CreateDatabase();
            _testDb.InitTestSchema();
            _testDb.PopulateTestAccelData();
            string databaseFile = _testDbFile;
            ILogger logger = new LoggerStub();
            var target = new LocalDatabaseStorage(databaseFile, logger);
            target.Open();

            var actual = target.GetAccelData();

            Assert.AreEqual(3,actual.Count);

            target.Close();
        }
Example #6
0
        public void UnexpectedExceptionTest()
        {
            var portMock = new Mock<IBinaryPort>();
            // выбрасываем неожидаемое потоком исключение
            portMock.Setup(foo => foo.ReadBytesBlock(1)).Throws<NullReferenceException>();
            var loggerStub = new LoggerStub();

            var target = new PortListener(portMock.Object, loggerStub);
            var syncEvent = new AutoResetEvent(false);
            Exception actual = null;
            target.ExceptionCought += (sender, e) =>
                                          {
                                              actual = e.Ex;
                                              syncEvent.Set();
                                          };

            target.StartListen();
            if (!syncEvent.WaitOne(5000))
            {
                Assert.Fail("Таймаут ожидания исключения");
            }

            Assert.IsFalse(target.IsListen, "поток остановлен");
            Assert.IsNotNull(actual as NullReferenceException, "передано правильно исключение");
            target.StopListen();
        }
Example #7
0
        public void StopListenTest()
        {
            var portMock = new Mock<IBinaryPort>();
            portMock.Setup(foo => foo.ReadBytesBlock(1)).Returns(new byte[] {0xA}); // возвращаем сигнатуру
            portMock.Setup(foo => foo.ReadBytesBlock(16)).Returns(new byte[]
                                                                      {
                                                                          0, 0, 0, 0, 0, 0, 52, 64, 0, 0, 0, 0, 0, 192, 82,
                                                                          192
                                                                      }); // возвращаем тело пакета
            var loggerStub = new LoggerStub();

            var target = new PortListener(portMock.Object, loggerStub);
            target.StartListen();
            target.StopListen();
            Assert.IsFalse(target.IsListen, "поток остановлен");
        }
 public void ConstructorWidthDbCreationTest()
 {
     string databaseFile = _testDbFile;
     ILogger logger = new LoggerStub();
     LocalDatabaseStorage target = new LocalDatabaseStorage(databaseFile, logger);
 }
        public void SaveCalibrationResultWithoutTest()
        {
            _testDb.CreateDatabase();
            _testDb.InitTestSchema();
            _testDb.PopulateTestAccelData();
            _testDb.PopulateTestAccelParams();
            _testDb.PopulateTestCalibrationResult();
            string databaseFile = _testDbFile;
            ILogger logger = new LoggerStub();
            var target = new LocalDatabaseStorage(databaseFile, logger);
            target.Open();
            var data = new CalibrationResult
            {
                Clusters = new List<AccelData>
                                              {
                                                  new AccelData { Id = 1,Date = DateTime.Now,Ax = 10.0, Ay = 20.0},
                                                  new AccelData { Id = 2,Date = DateTime.Now,Ax = 20.0, Ay = 30.0}
                                              },
                Parameters = new AccelParams { Id = 1,Date = DateTime.Now }
            };

            target.SaveCalibrationResult(data);

            Assert.AreEqual(_testDb.GetIdCount("accel_params"), 3, "проверяем, что калибровочные параметры не добавлены");
            Assert.AreEqual(_testDb.GetIdCount("accel_data"), 3, "проверяем, что данные акселерометров не добавлены");
            Assert.AreEqual(_testDb.GetIdCount("calibr_result"), 2, "проверяем, что результаты калибровки записаны заново");

            target.Close();
        }
        public void SaveAccelParamsTest()
        {
            string databaseFile = _testDbFile;
            ILogger logger = new LoggerStub();
            var target = new LocalDatabaseStorage(databaseFile, logger);
            target.Open();
            var data = new AccelParams { Date = DateTime.Now };

            target.SaveAccelParams(data);

            var idCount = _testDb.GetIdCount("accel_params");
            Assert.AreEqual(idCount, 1, "проверяем, что запись добавлена");
            Assert.AreEqual(1, data.Id, "проверяем, что изменен идентификатор записи в базе");

            target.Close();
        }
        public void OpenTestWithSchemaCreation()
        {
            _testDb.CreateDatabase();
            string databaseFile = _testDbFile;
            ILogger logger = new LoggerStub();

            LocalDatabaseStorage target = new LocalDatabaseStorage(databaseFile, logger);

            target.Open();

            Assert.IsTrue(_testDb.IsDatabaseExists(), "проверка создания файла базы данных");
            Assert.IsTrue(_testDb.IsTableExist("accel_data"), "проверка создания таблицы данных акселерометров");
            Assert.IsTrue(_testDb.IsTableExist("accel_params"), "проверка создания таблицы калибровочных данных");
            Assert.IsTrue(_testDb.IsTableExist("calibr_result"), "проверка создания таблица для результатов калибровки");

            target.Close();
        }
        public void MultipleSaveAccelDataTest()
        {
            string databaseFile = _testDbFile;
            ILogger logger = new LoggerStub();
            var target = new LocalDatabaseStorage(databaseFile, logger);
            target.Open();
            var data = new AccelData(10.0, 50.0);
            data.Date = DateTime.Now;

            target.SaveAccelData(data);
            target.SaveAccelData(data);
            target.SaveAccelData(data);

            var idCount = _testDb.GetIdCount("accel_data");
            Assert.AreEqual(idCount, 1, "проверяем, что запись не была добавлена несколько раз");
            Assert.AreEqual(1, data.Id, "проверяем, что изменен идентификатор записи в базе не изменился");

            target.Close();
        }
        public void GetCalibrationResultByParamsTest()
        {
            _testDb.CreateDatabase();
            _testDb.InitTestSchema();
            _testDb.PopulateTestAccelData();
            _testDb.PopulateTestAccelParams();
            _testDb.PopulateTestCalibrationResult();
            string databaseFile = _testDbFile;
            ILogger logger = new LoggerStub();
            var target = new LocalDatabaseStorage(databaseFile, logger);
            target.Open();
            var parameters = new AccelParams {Id = 1};

            var actual = target.GetCalibrationResultByParams(parameters);

            Assert.AreEqual(2,actual.Clusters.Count);

            target.Close();
        }
        public void GetAccelParamsBySensorNumberTest()
        {
            _testDb.CreateDatabase();
            _testDb.InitTestSchema();
            _testDb.PopulateTestAccelParams();
            string databaseFile = _testDbFile;
            ILogger logger = new LoggerStub();
            var target = new LocalDatabaseStorage(databaseFile, logger);
            target.Open();
            var data = new AccelData(10.0, 50.0);
            data.Date = DateTime.Now;

            var actual = target.GetAccelParamsBySensorNumber(1);

            Assert.AreEqual(2, actual.Count);

            target.Close();
        }