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); }