C++ testing::Eq方法代码示例

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_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(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(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, 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, 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));
}

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