TEST(NAME, empty_directory)
{
struct list_t* list = list_create();
#define SEARCH_DIR_EMPTY "tests/test_dir/empty/"
EXPECT_THAT(get_directory_listing(list, SEARCH_DIR_EMPTY), Ne(0));
EXPECT_THAT(list->count, Eq(2)); /* current and parent directory */
EXPECT_THAT(list_find(list, SEARCH_DIR_EMPTY "."), Ne(0));
EXPECT_THAT(list_find(list, SEARCH_DIR_EMPTY ".."), Ne(0));
LIST_FOR_EACH(list, char, file)
free_string(file);
list_destroy(list);
}
TEST_F(AntennaDriverTest, TestHardResetBothChannelsFailure)
{
EXPECT_CALL(primary, Reset(ANTENNA_PRIMARY_CHANNEL)).WillOnce(Return(OSResult::DeviceNotFound));
EXPECT_CALL(primary, Reset(ANTENNA_BACKUP_CHANNEL)).WillOnce(Return(OSResult::DeviceNotFound));
const auto result = driver.HardReset(&driver);
ASSERT_THAT(result, Ne(OSResult::Success));
}
TEST_F(AntennaDriverTest, TestResetStatusFailure)
{
EXPECT_CALL(primary, Reset(ANTENNA_BACKUP_CHANNEL)).WillOnce(Return(OSResult::DeviceNotFound));
const auto result = driver.Reset(&driver, ANTENNA_BACKUP_CHANNEL);
ASSERT_THAT(result, Ne(OSResult::Success));
ASSERT_THAT(driver.secondaryChannel.status, Eq(ANTENNA_PORT_FAILURE));
}
TEST_F(AntennaDriverTest, TestFinishDeploymentDisarmingFailure)
{
ON_CALL(primary, CancelAntennaDeployment(_)).WillByDefault(Return(OSResult::Success));
ON_CALL(primary, DisarmDeploymentSystem(_)).WillByDefault(Return(OSResult::DeviceNotFound));
const auto result = driver.FinishDeployment(&driver, ANTENNA_PRIMARY_CHANNEL);
ASSERT_THAT(result, Ne(OSResult::Success));
}
TEST_F(AntennaDriverTest, TestManualDeploymentFailure)
{
ON_CALL(primary, ArmDeploymentSystem(_)).WillByDefault(Return(OSResult::Success));
EXPECT_CALL(primary, DeployAntenna(ANTENNA_BACKUP_CHANNEL, ANTENNA3_ID, _, false)).WillOnce(Return(OSResult::DeviceNotFound));
const auto status = driver.DeployAntenna(&driver, ANTENNA_BACKUP_CHANNEL, ANTENNA3_ID, TimeSpanFromSeconds(20), false);
ASSERT_THAT(status, Ne(OSResult::Success));
}
TEST_F(AntennaDriverTest, TestGetTemperatureFailure)
{
EXPECT_CALL(primary, GetTemperature(ANTENNA_BACKUP_CHANNEL, _)).WillOnce(Return(OSResult::IOError));
uint16_t result;
const auto status = driver.GetTemperature(&driver, ANTENNA_BACKUP_CHANNEL, &result);
ASSERT_THAT(status, Ne(OSResult::Success));
}
TEST_F(AntennaMiniportTest, TestAntennaTemperatureFailure)
{
EXPECT_CALL(i2c, WriteRead(ANTENNA_PRIMARY_CHANNEL, ElementsAre(QueryTemperature), _)).WillOnce(Return(I2CResult::Nack));
uint16_t response;
const auto status = miniport.GetTemperature(&miniport, &i2c, ANTENNA_PRIMARY_CHANNEL, &response);
ASSERT_THAT(status, Ne(OSResult::Success));
ASSERT_THAT(response, Eq(0u));
}
TEST_F(AntennaMiniportTest, TestAntennaActivationTimeFailure)
{
EXPECT_CALL(i2c, WriteRead(ANTENNA_PRIMARY_CHANNEL, ElementsAre(QueryActivationTime2), _)).WillOnce(Return(I2CResult::Nack));
TimeSpan response;
const auto status = miniport.GetAntennaActivationTime(&miniport, &i2c, ANTENNA_PRIMARY_CHANNEL, ANTENNA2_ID, &response);
ASSERT_THAT(status, Ne(OSResult::Success));
ASSERT_THAT(response, Eq(TimeSpanFromMilliseconds(0u)));
}
TEST_F(AntennaMiniportTest, TestAntennaActivationCountFailure)
{
EXPECT_CALL(i2c, WriteRead(ANTENNA_BACKUP_CHANNEL, ElementsAre(QueryActivationCount2), _)).WillOnce(Return(I2CResult::Nack));
uint16_t response;
const auto status = miniport.GetAntennaActivationCount(&miniport, &i2c, ANTENNA_BACKUP_CHANNEL, ANTENNA2_ID, &response);
ASSERT_THAT(status, Ne(OSResult::Success));
ASSERT_THAT(response, Eq(0u));
}
TEST_F(TimeTaskTest, TestTimeUpdateFailure)
{
auto proxy = InstallProxy(&mock);
EXPECT_CALL(mock, TakeSemaphore(_, _)).WillOnce(Return(OSResult::IOError));
provider.CurrentTime = TimeSpanFromSeconds(12345678);
const auto result = updateDescriptor.updateProc(state, updateDescriptor.param);
ASSERT_THAT(result, Eq(UpdateResult::Warning));
ASSERT_THAT(state.Time, Ne(TimeSpanFromSeconds(12345678)));
}
TEST(NAME, files_and_directories)
{
int i = 0;
struct list_t* list = list_create();
#define SEARCH_DIR_FILES "tests/test_dir/files/"
EXPECT_THAT(get_directory_listing(list, SEARCH_DIR_FILES), Ne(0));
EXPECT_THAT(list->count, Eq(7));
EXPECT_THAT(list_find(list, SEARCH_DIR_FILES "."), Ne(0));
EXPECT_THAT(list_find(list, SEARCH_DIR_FILES ".."), Ne(0));
EXPECT_THAT(list_find(list, SEARCH_DIR_FILES "file_a.txt"), Ne(0));
EXPECT_THAT(list_find(list, SEARCH_DIR_FILES "file_b.txt"), Ne(0));
EXPECT_THAT(list_find(list, SEARCH_DIR_FILES "file_c.txt"), Ne(0));
EXPECT_THAT(list_find(list, SEARCH_DIR_FILES "dir_a"), Ne(0));
EXPECT_THAT(list_find(list, SEARCH_DIR_FILES "dir_b"), Ne(0));
LIST_FOR_EACH(list, char, file)
free_string(file);
list_destroy(list);
}
TEST_F(AntennaMiniportTest, TestAutomaticDeploymentFailure)
{
EXPECT_CALL(i2c, Write(ANTENNA_PRIMARY_CHANNEL, BeginsWith(StartDeployment))).WillOnce(Return(I2CResult::Nack));
const auto status = miniport.InitializeAutomaticDeployment(&miniport, &i2c, ANTENNA_PRIMARY_CHANNEL, TimeSpanFromSeconds(200));
ASSERT_THAT(status, Ne(OSResult::Success));
}
TEST_F(AntennaMiniportTest, TestDisarmingDeploymentFailure)
{
i2c.ExpectWriteCommand(ANTENNA_PRIMARY_CHANNEL, Disarm).WillOnce(Return(I2CResult::Nack));
const auto status = miniport.DisarmDeploymentSystem(&miniport, &i2c, ANTENNA_PRIMARY_CHANNEL);
ASSERT_THAT(status, Ne(OSResult::Success));
}
TEST_F(AntennaMiniportTest, TestHardwareResetFailure)
{
i2c.ExpectWriteCommand(ANTENNA_PRIMARY_CHANNEL, Reset).WillOnce(Return(I2CResult::Nack));
const auto status = miniport.Reset(&miniport, &i2c, ANTENNA_PRIMARY_CHANNEL);
ASSERT_THAT(status, Ne(OSResult::Success));
}
TEST_F(AntennaDriverTest, TestDeployAntennaArmingFailure)
{
EXPECT_CALL(primary, ArmDeploymentSystem(ANTENNA_PRIMARY_CHANNEL)).WillOnce(Return(OSResult::DeviceNotFound));
const auto status = driver.DeployAntenna(&driver, ANTENNA_PRIMARY_CHANNEL, ANTENNA3_ID, TimeSpanFromSeconds(10), false);
ASSERT_THAT(status, Ne(OSResult::Success));
}
TEST_F(AntennaMiniportTest, TestCancelAutomaticDeploymentFailure)
{
i2c.ExpectWriteCommand(ANTENNA_PRIMARY_CHANNEL, CancelDeployment).WillOnce(Return(I2CResult::Nack));
const auto status = miniport.CancelAntennaDeployment(&miniport, &i2c, ANTENNA_PRIMARY_CHANNEL);
ASSERT_THAT(status, Ne(OSResult::Success));
}
TEST_F(AntennaMiniportTest, TestManualAntennaDeploymentWithOverrideFailure)
{
EXPECT_CALL(i2c, Write(ANTENNA_BACKUP_CHANNEL, ElementsAre(DeployAntenna3Override, 200u))).WillOnce(Return(I2CResult::Nack));
const auto status = miniport.DeployAntenna(&miniport, &i2c, ANTENNA_BACKUP_CHANNEL, ANTENNA3_ID, TimeSpanFromSeconds(200), true);
ASSERT_THAT(status, Ne(OSResult::Success));
}
