TEST(CommFrameTest, TestSimpleEmptyFrame)
{
CommFrame frame(1, 2, 0, gsl::span<std::uint8_t>());
ASSERT_THAT(frame.Size(), Eq(0));
ASSERT_THAT(frame.FullSize(), Eq(0));
ASSERT_THAT(frame.Payload().empty(), Eq(true));
}
TEST(CommFrameTest, TestSimpleFrameDoppleVerification)
{
std::uint8_t buffer[10];
CommFrame frame(0xfff, 1, 10, buffer);
ASSERT_THAT(frame.IsDopplerValid(), Eq(true));
ASSERT_THAT(frame.Verify(), Eq(true));
}
TEST(CommFrameTest, TestSimpleFrameDopplerVerificationFailure)
{
std::uint8_t buffer[10];
CommFrame frame(0xf000, 1, 10, buffer);
ASSERT_THAT(frame.IsDopplerValid(), Eq(false));
ASSERT_THAT(frame.Verify(), Eq(false));
}
TEST_F(WavFileWriterTest, shouldCreateEmptyWavFile)
{
boost::filesystem::path filename = FileUtil::getTempFilename();
// Ensure temporary file is deleted at end of test.
FileDeleter deleter(filename);
WavFileWriter writer(filename.c_str());
const int sample_rate = 44100;
const int channels = 1;
const int BUFFER_SIZE = 1024;
bool success = writer.init(sample_rate, channels, BUFFER_SIZE);
ASSERT_TRUE(success);
writer.done();
boost::system::error_code error_code;
boost::uintmax_t size = boost::filesystem::file_size(filename, error_code);
// Check file was created.
ASSERT_THAT(error_code, Eq(boost::system::errc::success));
// Check file size: 44 byte WAV header
ASSERT_THAT(size, Eq(44U));
// Check no error reported.
ASSERT_TRUE(error.str().empty());
}
TEST_F(AntennaDriverTest, TestHardResetSecondaryStatusFailure)
{
EXPECT_CALL(primary, Reset(ANTENNA_PRIMARY_CHANNEL)).WillOnce(Return(OSResult::Success));
EXPECT_CALL(primary, Reset(ANTENNA_BACKUP_CHANNEL)).WillOnce(Return(OSResult::DeviceNotFound));
const auto result = driver.HardReset(&driver);
ASSERT_THAT(result, Eq(OSResult::Success));
ASSERT_THAT(driver.secondaryChannel.status, Eq(ANTENNA_PORT_FAILURE));
}
TEST(ReaderTest, TestSkipToTheLimit)
{
uint8_t array[] = {0x55, 0xaa};
Reader reader(array);
ASSERT_THAT(reader.Skip(2), Eq(true));
ASSERT_TRUE(reader.Status());
ASSERT_THAT(reader.RemainingSize(), Eq(0));
}
TEST_F(AntennaDriverTest, TestResetStatusSuccess)
{
driver.primaryChannel.status = ANTENNA_PORT_FAILURE;
EXPECT_CALL(primary, Reset(ANTENNA_PRIMARY_CHANNEL)).WillOnce(Return(OSResult::Success));
const auto result = driver.Reset(&driver, ANTENNA_PRIMARY_CHANNEL);
ASSERT_THAT(result, Eq(OSResult::Success));
ASSERT_THAT(driver.primaryChannel.status, Eq(ANTENNA_PORT_OPERATIONAL));
}
TEST_F(AntennaDriverTest, TestHardResetStatusSuccess)
{
EXPECT_CALL(primary, Reset(ANTENNA_PRIMARY_CHANNEL)).WillOnce(Return(OSResult::Success));
EXPECT_CALL(primary, Reset(ANTENNA_BACKUP_CHANNEL)).WillOnce(Return(OSResult::Success));
const auto result = driver.HardReset(&driver);
ASSERT_THAT(result, Eq(OSResult::Success));
ASSERT_THAT(driver.primaryChannel.status, Eq(ANTENNA_PORT_OPERATIONAL));
ASSERT_THAT(driver.secondaryChannel.status, Eq(ANTENNA_PORT_OPERATIONAL));
}
TEST(NAME, invalid_directory)
{
struct list_t* list = list_create();
EXPECT_THAT(get_directory_listing(list, "tests/test_dir/invalid/"), Eq(0));
EXPECT_THAT(list->count, Eq(0));
list_destroy(list);
}
TEST(CommFrameTest, TestEmptyFrame)
{
CommFrame frame;
ASSERT_THAT(frame.Size(), Eq(0));
ASSERT_THAT(frame.FullSize(), Eq(0));
ASSERT_THAT(frame.Rssi(), Eq(0));
ASSERT_THAT(frame.Doppler(), Eq(0));
ASSERT_THAT(frame.Payload().empty(), Eq(true));
}
TEST(PvalLocus, DirectInitialization) {
PvalLocus plocus(0, 3000573, 0.2273);
ASSERT_THAT(plocus.chrom_ind, Eq(0));
ASSERT_THAT(plocus.pos, Eq(3000573));
ASSERT_THAT(plocus.raw_pval, Eq(0.2273));
ASSERT_THAT(plocus.combined_pval, Eq(0));
ASSERT_THAT(plocus.corrected_pval, Eq(0));
}
TEST_F(TimeTaskTest, TestTimeUpdate)
{
auto proxy = InstallProxy(&mock);
EXPECT_CALL(mock, TakeSemaphore(_, _)).WillOnce(Return(OSResult::Success));
provider.CurrentTime = TimeSpanFromSeconds(12345678);
const auto result = updateDescriptor.updateProc(state, updateDescriptor.param);
ASSERT_THAT(result, Eq(UpdateResult::Ok));
ASSERT_THAT(state.Time, Eq(TimeSpanFromSeconds(12345678)));
}
TEST_F(Documents, UpdateReturnsUpdatedDocument)
{
ClangBackEnd::FileContainer createFileContainer(filePath, projectPartId, Utf8StringVector(), 74u);
ClangBackEnd::FileContainer updateFileContainer(filePath, Utf8String(), Utf8StringVector(), 75u);
documents.create({createFileContainer});
const std::vector<Document> updatedDocuments = documents.update({updateFileContainer});
ASSERT_THAT(updatedDocuments.size(), Eq(1u));
ASSERT_THAT(updatedDocuments.front().documentRevision(), Eq(75u));
}
TEST_F(AntennaMiniportTest, TestAntennaActivationTime)
{
EXPECT_CALL(i2c, WriteRead(ANTENNA_PRIMARY_CHANNEL, ElementsAre(QueryActivationTime1), _))
.WillOnce(Invoke([=](uint8_t /*address*/, span<const uint8_t> /*inData*/, span<uint8_t> outData) {
std::fill(outData.begin(), outData.end(), 0);
outData[0] = 10;
return I2CResult::OK;
}));
TimeSpan response;
const auto status = miniport.GetAntennaActivationTime(&miniport, &i2c, ANTENNA_PRIMARY_CHANNEL, ANTENNA1_ID, &response);
ASSERT_THAT(status, Eq(OSResult::Success));
ASSERT_THAT(response, Eq(TimeSpanFromMilliseconds(128000)));
}
TEST_F(AntennaMiniportTest, TestAntennaTemperatureOutOfRange)
{
EXPECT_CALL(i2c, WriteRead(ANTENNA_PRIMARY_CHANNEL, ElementsAre(QueryTemperature), _))
.WillOnce(Invoke([=](uint8_t /*address*/, span<const uint8_t> /*inData*/, span<uint8_t> outData) {
std::fill(outData.begin(), outData.end(), 0);
outData[0] = 0xfc;
outData[1] = 0;
return I2CResult::OK;
}));
uint16_t response;
const auto status = miniport.GetTemperature(&miniport, &i2c, ANTENNA_PRIMARY_CHANNEL, &response);
ASSERT_THAT(status, Eq(OSResult::OutOfRange));
ASSERT_THAT(response, Eq(0));
}
TEST_F(AntennaDriverTest, TestGetTemperature)
{
EXPECT_CALL(primary, GetTemperature(ANTENNA_PRIMARY_CHANNEL, _))
.WillOnce(Invoke([](AntennaChannel channel, uint16_t* value) //
{
UNREFERENCED_PARAMETER(channel);
*value = 10;
return OSResult::Success;
}));
uint16_t result;
const auto status = driver.GetTemperature(&driver, ANTENNA_PRIMARY_CHANNEL, &result);
ASSERT_THAT(status, Eq(OSResult::Success));
ASSERT_THAT(result, Eq(10));
}
TEST(StringUtilTest, testConcatWithDelimiterForEmptyB) {
string A = "AString";
string B = "";
char delimiter = ':';
EXPECT_THAT(StringUtil::concatWithDelimiter(A, B, delimiter), Eq("AString:"));
}
TEST_F(AntennaDriverTest, TestGetTelemetryPositiveTestSecondaryChannel)
{
EXPECT_CALL(primary, GetTemperature(ANTENNA_BACKUP_CHANNEL, _)).WillOnce(Return(OSResult::Success));
EXPECT_CALL(primary, GetAntennaActivationCount(ANTENNA_BACKUP_CHANNEL, _, _)).Times(4).WillRepeatedly(Return(OSResult::Success));
EXPECT_CALL(primary, GetAntennaActivationTime(ANTENNA_BACKUP_CHANNEL, _, _)).Times(4).WillRepeatedly(Return(OSResult::Success));
EXPECT_CALL(primary, GetTemperature(ANTENNA_PRIMARY_CHANNEL, _)).WillOnce(Return(OSResult::DeviceNotFound));
EXPECT_CALL(primary, GetAntennaActivationCount(ANTENNA_PRIMARY_CHANNEL, _, _))
.Times(4)
.WillRepeatedly(Return(OSResult::DeviceNotFound));
EXPECT_CALL(primary, GetAntennaActivationTime(ANTENNA_PRIMARY_CHANNEL, _, _)).Times(4).WillRepeatedly(Return(OSResult::DeviceNotFound));
const auto result = driver.GetTelemetry(&driver);
ASSERT_THAT(result.flags,
Eq(static_cast<uint32_t>(ANT_TM_ANTENNA1_ACTIVATION_COUNT | //
ANT_TM_ANTENNA2_ACTIVATION_COUNT | //
ANT_TM_ANTENNA3_ACTIVATION_COUNT | //
ANT_TM_ANTENNA4_ACTIVATION_COUNT | //
ANT_TM_ANTENNA1_ACTIVATION_TIME | //
ANT_TM_ANTENNA2_ACTIVATION_TIME | //
ANT_TM_ANTENNA3_ACTIVATION_TIME | //
ANT_TM_ANTENNA4_ACTIVATION_TIME | //
ANT_TM_TEMPERATURE2 //
)));
}
TEST_F(AntennaDriverTest, TestAutomaticDeploymentSuccess)
{
ON_CALL(primary, ArmDeploymentSystem(_)).WillByDefault(Return(OSResult::Success));
EXPECT_CALL(primary, InitializeAutomaticDeployment(ANTENNA_BACKUP_CHANNEL, _)).WillOnce(Return(OSResult::Success));
const auto status = driver.DeployAntenna(&driver, ANTENNA_BACKUP_CHANNEL, ANTENNA_AUTO_ID, TimeSpanFromSeconds(20), false);
ASSERT_THAT(status, Eq(OSResult::Success));
}
TEST_F(AntennaDriverTest, TestManualDeploymentSuccessWithOverride)
{
ON_CALL(primary, ArmDeploymentSystem(_)).WillByDefault(Return(OSResult::Success));
EXPECT_CALL(primary, DeployAntenna(ANTENNA_BACKUP_CHANNEL, ANTENNA3_ID, _, true)).WillOnce(Return(OSResult::Success));
const auto status = driver.DeployAntenna(&driver, ANTENNA_BACKUP_CHANNEL, ANTENNA3_ID, TimeSpanFromSeconds(20), true);
ASSERT_THAT(status, Eq(OSResult::Success));
}
TEST_F(AntennaDriverTest, TestFinishDeploymentDisarmsDeploymentSystem)
{
ON_CALL(primary, CancelAntennaDeployment(_)).WillByDefault(Return(OSResult::Success));
EXPECT_CALL(primary, DisarmDeploymentSystem(ANTENNA_PRIMARY_CHANNEL)).WillOnce(Return(OSResult::Success));
const auto result = driver.FinishDeployment(&driver, ANTENNA_PRIMARY_CHANNEL);
ASSERT_THAT(result, Eq(OSResult::Success));
}
TEST(StringUtilTest, testConcatWithDelimiterVerifyOuterDelimitersStay) {
string A = "::AString";
string B = "BString::";
char delimiter = ':';
EXPECT_THAT(StringUtil::concatWithDelimiter(A, B, delimiter), Eq("::AString:BString::"));
}
TEST(StringUtilTest, testConcatWithDelimiterWithoutPresentDelimiter) {
string A = "AString";
string B = "BString";
char delimiter = ':';
EXPECT_THAT(StringUtil::concatWithDelimiter(A, B, delimiter), Eq("AString:BString"));
}
void GdImageRendererTest::testImageRendering(bool axis_labels)
{
const char* filename = temp_filename_.getFilename();
ASSERT_NE(nullptr, filename);
// Ensure temporary file is deleted at end of test.
FileDeleter deleter(filename);
bool result = buffer_.load("../test/data/test_file_stereo_8bit_64spp.dat");
ASSERT_TRUE(result);
const WaveformColors& colors = audacityWaveformColors;
result = renderer_.create(buffer_, 5.0, 1000, 300, colors, axis_labels); // zoom: 128
ASSERT_TRUE(result);
result = renderer_.saveAsPng(filename);
ASSERT_TRUE(result);
struct stat info;
int stat_result = stat(filename, &info);
ASSERT_THAT(stat_result, Eq(0));
ASSERT_THAT(info.st_size, Gt(0));
ASSERT_FALSE(output.str().empty());
ASSERT_TRUE(error.str().empty());
}
TEST(StringUtilTest, testConcatWithDelimiterWithMultipleDelimiters) {
string A = "AString:::";
string B = "::BString";
char delimiter = ':';
EXPECT_THAT(StringUtil::concatWithDelimiter(A, B, delimiter), Eq("AString:BString"));
}
// This test ensures that the slave will re-register with the master
// if it does not receive any pings after registering.
TEST_F(SlaveTest, PingTimeoutNoPings)
{
// Start a master.
Try<PID<Master> > master = StartMaster();
ASSERT_SOME(master);
// Block all pings to the slave.
DROP_MESSAGES(Eq("PING"), _, _);
Future<SlaveRegisteredMessage> slaveRegisteredMessage =
FUTURE_PROTOBUF(SlaveRegisteredMessage(), _, _);
// Start a slave.
Try<PID<Slave> > slave = StartSlave();
ASSERT_SOME(slave);
AWAIT_READY(slaveRegisteredMessage);
// Ensure the slave processes the registration message and schedules
// the ping timeout, before we advance the clock.
Clock::pause();
Clock::settle();
// Advance to the ping timeout to trigger a re-detection and
// re-registration.
Future<Nothing> detected = FUTURE_DISPATCH(_, &Slave::detected);
Future<SlaveReregisteredMessage> slaveReregisteredMessage =
FUTURE_PROTOBUF(SlaveReregisteredMessage(), _, _);
Clock::advance(slave::MASTER_PING_TIMEOUT());
AWAIT_READY(detected);
AWAIT_READY(slaveReregisteredMessage);
}
TEST(ReaderTest, TestSkipOverTheLimit)
{
uint8_t array[] = {0x55, 0xaa};
Reader reader(array);
ASSERT_THAT(reader.Skip(3), Eq(false));
ASSERT_FALSE(reader.Status());
}
TEST_F(SmartWaitTest, ShouldAbortAfterWaitError)
{
EXPECT_CALL(osMock, PulseWait(_, _)).WillOnce(Return(OSResult::NotSupported));
auto result = TimeLongDelay(&timeProvider, TimeSpanFromDays(1));
ASSERT_THAT(result, Eq(false));
}
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)));
}
// This test verifies that if master --> slave socket closes and the
// slave is not aware of it (i.e., one way network partition), slave
// will re-register with the master.
TEST_F(PartitionTest, OneWayPartitionMasterToSlave)
{
// Start a master.
Try<PID<Master> > master = StartMaster();
ASSERT_SOME(master);
Future<Message> slaveRegisteredMessage =
FUTURE_MESSAGE(Eq(SlaveRegisteredMessage().GetTypeName()), _, _);
// Ensure a ping reaches the slave.
Future<Message> ping = FUTURE_MESSAGE(Eq("PING"), _, _);
// Start a checkpointing slave.
slave::Flags flags = CreateSlaveFlags();
flags.checkpoint = true;
Try<PID<Slave> > slave = StartSlave(flags);
ASSERT_SOME(slave);
AWAIT_READY(slaveRegisteredMessage);
AWAIT_READY(ping);
Future<Nothing> deactivateSlave =
FUTURE_DISPATCH(_, &AllocatorProcess::deactivateSlave);
// Inject a slave exited event at the master causing the master
// to mark the slave as disconnected. The slave should not notice
// it until the next ping is received.
process::inject::exited(slaveRegisteredMessage.get().to, master.get());
// Wait until master deactivates the slave.
AWAIT_READY(deactivateSlave);
Future<SlaveReregisteredMessage> slaveReregisteredMessage =
FUTURE_PROTOBUF(SlaveReregisteredMessage(), _, _);
// Ensure the slave observer marked the slave as deactivated.
Clock::pause();
Clock::settle();
// Let the slave observer send the next ping.
Clock::advance(slave::MASTER_PING_TIMEOUT());
// Slave should re-register.
AWAIT_READY(slaveReregisteredMessage);
}
