自学教程：C++ ASSERT_FLOAT_EQ函数代码示例

TEST(YogaTest, all_overridden) {  const YGNodeRef root = YGNodeNew();  YGNodeStyleSetFlexDirection(root, YGFlexDirectionColumn);  YGNodeStyleSetWidth(root, 100);  YGNodeStyleSetHeight(root, 100);  const YGNodeRef root_child0 = YGNodeNew();  YGNodeStyleSetFlexGrow(root_child0, 1);  YGNodeStyleSetMargin(root_child0, YGEdgeLeft, 10);  YGNodeStyleSetMargin(root_child0, YGEdgeTop, 10);  YGNodeStyleSetMargin(root_child0, YGEdgeRight, 10);  YGNodeStyleSetMargin(root_child0, YGEdgeBottom, 10);  YGNodeStyleSetMargin(root_child0, YGEdgeAll, 20);  YGNodeInsertChild(root, root_child0, 0);  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetLeft(root_child0));  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetTop(root_child0));  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetRight(root_child0));  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetBottom(root_child0));  YGNodeFreeRecursive(root);}

TEST(TestISTLMatrix, AssembleMPI){  InspectMatrixSIM sim(1);  sim.read("src/LinAlg/Test/refdata/petsc_test.xinp");  sim.opt.solver = SystemMatrix::ISTL;  sim.preprocess();  sim.initSystem(SystemMatrix::ISTL);  Matrix stencil(4,4);  stencil(1,1) = stencil(2,2) = stencil(3,3) = stencil(4,4) = 1.0;  for (int iel = 1; iel <= sim.getSAM()->getNoElms(); ++iel)    sim.getMatrix()->assemble(stencil, *sim.getSAM(), iel);  sim.getMatrix()->beginAssembly();  sim.getMatrix()->endAssembly();  // now inspect the matrix  const ProcessAdm& adm = sim.getProcessAdm();  ISTL::Mat& mat = static_cast<ISTLMatrix*>(sim.getMatrix())->getMatrix();  ISTL::Vec b(mat.N()), b2(mat.N());  try {    Dune::OwnerOverlapCopyCommunication<int,int> comm(*adm.getCommunicator());    comm.indexSet().beginResize();    typedef Dune::ParallelLocalIndex<Dune::OwnerOverlapCopyAttributeSet::AttributeSet> LI;    for (size_t i = 0; i < adm.dd.getMLGEQ().size(); ++i) {      int gid = adm.dd.getGlobalEq(i+1);      comm.indexSet().add(gid-1, LI(i, gid >= adm.dd.getMinEq() ?                                       Dune::OwnerOverlapCopyAttributeSet::owner :                                       Dune::OwnerOverlapCopyAttributeSet::overlap));    }    comm.indexSet().endResize();    comm.remoteIndices().setIncludeSelf(true);    comm.remoteIndices().template rebuild<false>();    ISTL::ParMatrixAdapter op(mat, comm);    b = 1.0;    op.apply(b, b2);  } catch (Dune::ISTLError& e) {    std::cerr << e << std::endl;    ASSERT_TRUE(false);  }  IntVec v = readIntVector("src/LinAlg/Test/refdata/petsc_matrix_diagonal.ref");  for (size_t i = 1; i <= adm.dd.getMLGEQ().size(); ++i)    ASSERT_FLOAT_EQ(v[adm.dd.getGlobalEq(i)-1], b2[i-1]);}

TEST(FloatTest, SaveLoadTest){	INIT_DONUT;	std::string providerName;	XValue data;	{		Handler<FloatObject> obj( heap->createFloatObject(10.1) );		ASSERT_ANY_THROW(obj->toBool(heap));		ASSERT_ANY_THROW(obj->toInt(heap));		ASSERT_ANY_THROW(obj->toString(heap));		ASSERT_FLOAT_EQ(10.1, obj->toFloat(heap));		data = Handler<HeapObject>(obj)->save(heap);		providerName = obj->providerName(heap);	}	{		Handler<HeapObject> obj(new FloatObject(heap->findHeapProvider(providerName).get()));		obj->load(heap, data);		ASSERT_NO_THROW(obj.cast<FloatObject>());		ASSERT_ANY_THROW(obj->toBool(heap));		ASSERT_ANY_THROW(obj->toInt(heap));		ASSERT_ANY_THROW(obj->toString(heap));		ASSERT_FLOAT_EQ(10.1, obj->toFloat(heap));	}}

  void testit () {    d_results = Kokkos::View<Kokkos::complex<double>*,ExecSpace>("TestComplexSpecialFunctions",20);    h_results = Kokkos::create_mirror_view(d_results);    Kokkos::parallel_for(Kokkos::RangePolicy<ExecSpace>(0,1), *this);    Kokkos::fence();    Kokkos::deep_copy(h_results,d_results);    std::complex<double> a(1.5,2.5);    double c = 9.3;    std::complex<double> r;    r = a;             ASSERT_FLOAT_EQ(h_results(0).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(0).imag(),  r.imag());    r = std::sqrt(a);  ASSERT_FLOAT_EQ(h_results(1).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(1).imag(),  r.imag());    r = std::pow(a,c); ASSERT_FLOAT_EQ(h_results(2).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(2).imag(),  r.imag());    r = std::abs(a);   ASSERT_FLOAT_EQ(h_results(3).real(),  r.real()); ASSERT_FLOAT_EQ(h_results(3).imag(),  r.imag());  }

TEST_F(TrapezoidalTesting, DiagonalValue){	ASSERT_FLOAT_EQ(0.5, rect_left.CalculateMembership(5.5));	ASSERT_FLOAT_EQ(0.25, rect_left.CalculateMembership(5.75));	ASSERT_FLOAT_EQ(0.75, rect_left.CalculateMembership(5.25));	ASSERT_FLOAT_EQ(0.75, rect_right.CalculateMembership(2.75));	ASSERT_FLOAT_EQ(0.25, rect_right.CalculateMembership(2.25));	ASSERT_FLOAT_EQ(0.5, rect_right.CalculateMembership(2.5));	float m1 = 1.0 - 1.0 / 3.0;	float m2 = 1.0 - 2.0/ 3.0;	ASSERT_FLOAT_EQ(m1, normal.CalculateMembership(3));	ASSERT_FLOAT_EQ(m2, normal.CalculateMembership(4));}

TEST (AudioDataTest, DiscardFromFront) {  KeyFinder::AudioData a;  a.setChannels(1);  a.setFrameRate(1);  ASSERT_THROW(a.discardFramesFromFront(1), KeyFinder::Exception);  a.addToFrameCount(10);  ASSERT_THROW(a.discardFramesFromFront(11), KeyFinder::Exception);  ASSERT_NO_THROW(a.discardFramesFromFront(0));  a.setSampleByFrame(5, 0, 10.0);  ASSERT_NO_THROW(a.discardFramesFromFront(5));  ASSERT_EQ(5, a.getFrameCount());  ASSERT_FLOAT_EQ(10.0, a.getSampleByFrame(0, 0));}

TEST(CircularBufferSingle, TestMultiWriteRead){    const float data[4] = {1,2,3,4};    float out[4] = {0,0,0,0};    CircularBuffer *buffer = CircularBufferInit(7);    CircularBufferWrite(buffer, data, 2);    CircularBufferWrite(buffer, data + 2, 2);    CircularBufferRead(buffer, out, 4);    CircularBufferFree(buffer);        for (unsigned i = 0; i < 4; ++i)    {        ASSERT_FLOAT_EQ(out[i], data[i]);    }}

TEST(Quaternion, Normalize) {	narf::Quaternion<float> q1(3, -1, 4, 3);	ASSERT_FLOAT_EQ(q1.norm(), 5.91608f);	auto q2 = q1.normalize();	ASSERT_FLOAT_EQ(q2.norm(), 1.0f);	ASSERT_FLOAT_EQ(q2.w, 0.50709254f);	ASSERT_FLOAT_EQ(q2.v.x, -0.16903085f);	ASSERT_FLOAT_EQ(q2.v.y, 0.67612338f);	ASSERT_FLOAT_EQ(q2.v.z, 0.50709254f);}

TEST_F(VCFReaderTest, QualField) {	const char* value = nullptr;	sph_umich_edu::QualField field;	value = "";	ASSERT_THROW(field.parse(value, value + strlen(value)), sph_umich_edu::VCFException);	ASSERT_TRUE(field.is_empty());	value = ".";	ASSERT_NO_THROW(field.parse(value, value + strlen(value)));	ASSERT_TRUE(field.is_empty());	ASSERT_TRUE(std::isnan(field.get_value()));	value = "0";	ASSERT_NO_THROW(field.parse(value, value + strlen(value)));	ASSERT_FALSE(field.is_empty());	ASSERT_FLOAT_EQ(0.0, field.get_value());	value = "30";	ASSERT_NO_THROW(field.parse(value, value + strlen(value)));	ASSERT_FALSE(field.is_empty());	ASSERT_FLOAT_EQ(30.0, field.get_value());	value = "-30";	ASSERT_THROW(field.parse(value, value + strlen(value)), sph_umich_edu::VCFException);	ASSERT_TRUE(field.is_empty());	value = "12.2";	ASSERT_NO_THROW(field.parse(value, value + strlen(value)));	ASSERT_FALSE(field.is_empty());	ASSERT_FLOAT_EQ(12.2, field.get_value());	value = "12.0";	ASSERT_NO_THROW(field.parse(value, value + strlen(value)));	ASSERT_FALSE(field.is_empty());	ASSERT_FLOAT_EQ(12.0, field.get_value());	value = "0.0";	ASSERT_NO_THROW(field.parse(value, value + strlen(value)));	ASSERT_FALSE(field.is_empty());	ASSERT_FLOAT_EQ(0.0, field.get_value());	value = "0.12";	ASSERT_NO_THROW(field.parse(value, value + strlen(value)));	ASSERT_FALSE(field.is_empty());	ASSERT_FLOAT_EQ(0.12, field.get_value());	value = ".12";	ASSERT_THROW(field.parse(value, value + strlen(value)), sph_umich_edu::VCFException);	ASSERT_TRUE(field.is_empty());	value = "aBc";	ASSERT_THROW(field.parse(value, value + strlen(value)), sph_umich_edu::VCFException);	ASSERT_TRUE(field.is_empty());}

/// tests Matrix4 array getterTEST_F(Math_Matrix4Tests, ArrayGetter){    float in_array[] = {5,-71,-13,86,-86,-8,-62,8,-69,-106,81,125,-1,-52,84,47};    const float* out_array;        for(int i=0; i < 4; i++)    {        for (int j=0; j < 4; j++)            m1.set(i, j, in_array[i*4 + j]);    }        out_array = m1.getArray();        for(int i=0; i < 16; i++)        ASSERT_FLOAT_EQ(in_array[i], out_array[i]);}

TEST_F(TabuAlgorithmTest, BigTestOnRealData){    std::shared_ptr<Vrp::CvrpFile> l_file = std::make_shared<Vrp::CvrpFile>("../../dairyProblem/data/A-n69-k9.vrp");    Vrp::PolarCoordinatesMatrixConverter l_polarConv(Vrp::CvrpFileReader(l_file).getData());    TabuAlgorithm l_algorithm(l_polarConv.convertAndSortByAngle());    DairyPath l_result;    l_result.distance = 1281.9614;    l_result.path = {1, 30, 16, 28, 23, 10, 25, 19, 9, 15, 1,                     12, 5, 29, 24, 7, 4, 3, 27, 1, 14, 8, 18,                     20, 31, 32, 1, 17, 22, 2, 13, 21, 1, 26, 6, 11, 1};    //ASSERT_EQ(l_algorithm.compute().path, l_result.path);ASSERT_FLOAT_EQ(l_algorithm.compute().distance, l_result.distance);    //ASSERT_FLOAT_EQ(l_algorithm.getDistance(), l_result.distance);}

TEST(DSP, FloatDoubleConversion){    float in[10] = {1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0};    double out[10];    float fout[10];        FloatToDouble(out, in, 10);    for (unsigned i = 0; i < 10; ++i)    {        ASSERT_DOUBLE_EQ((double)in[i], out[i]);    }        DoubleToFloat(fout, out, 10);    for (unsigned i = 0; i < 10; ++i)    {        ASSERT_FLOAT_EQ(in[i], fout[i]);    }}

TEST_F(CConfigFileTest, ReadTest){    m_configFile.SetUseCurrentDirectory(true);    ASSERT_TRUE(m_configFile.Init()); // load colobot.ini file    std::string result;    ASSERT_TRUE(m_configFile.GetStringProperty("test_string", "string_value", result));    ASSERT_STREQ("Hello world", result.c_str());    int int_value;    ASSERT_TRUE(m_configFile.GetIntProperty("test_int", "int_value", int_value));    ASSERT_EQ(42, int_value);    float float_value;    ASSERT_TRUE(m_configFile.GetFloatProperty("test_float", "float_value", float_value));    ASSERT_FLOAT_EQ(1.5, float_value);}

    TEST(xphoto_DenoisingBm3dKaiserWindow, regression_4)    {        float beta = 2.0f;        int N = 4;        cv::Mat kaiserWindow;        calcKaiserWindow1D(kaiserWindow, N, beta);        float kaiser4[] = {            0.43869004f,            0.92432547f,            0.92432547f,            0.43869004f        };        for (int i = 0; i < N; ++i)            ASSERT_FLOAT_EQ(kaiser4[i], kaiserWindow.at<float>(i));    }

TEST(TestISTLPETScMatrix, SchurComplement){  ASMmxBase::Type = ASMmxBase::FULL_CONT_RAISE_BASIS1;  ASMmxBase::geoBasis = 2;  Matrix stencil(13,13);  for (size_t i = 1; i<= 13; ++i)    for (size_t j = 1; j <= 13; ++j)      stencil(i,j) = 1.0;  std::array<InspectMatrixSIM,2> sim;  for (size_t i = 0; i < 2; ++i) {    sim[i].read("src/LinAlg/Test/refdata/petsc_test_blocks_basis.xinp");    sim[i].opt.solver = i == 0 ? SystemMatrix::PETSC : SystemMatrix::ISTL;    sim[i].preprocess();    sim[i].initSystem(i == 0 ? SystemMatrix::PETSC : SystemMatrix::ISTL);    for (int iel = 1; iel <= sim[i].getSAM()->getNoElms(); ++iel)      sim[i].getMatrix()->assemble(stencil, *sim[i].getSAM(), iel);    sim[i].getMatrix()->beginAssembly();    sim[i].getMatrix()->endAssembly();  }  const ProcessAdm& adm = sim[1].getProcessAdm();  ISTL::Mat& A = static_cast<ISTLMatrix*>(sim[1].getMatrix())->getMatrix();  ISTL::BlockPreconditioner block(A, adm.dd, "upper");  ISTL::Mat& S = block.getBlock(1);  PETScSolParams params(LinSolParams(), adm);  params.setupSchurComplement(static_cast<PETScMatrix*>(sim[0].getMatrix())->getBlockMatrices());  // check that matrices are the same  for (size_t r = 0; r < S.N(); ++r) {    const PetscInt* cols;    PetscInt ncols;    const PetscScalar* vals;    MatGetRow(params.getSchurComplement(), r, &ncols, &cols, &vals);    for (PetscInt i = 0; i < ncols; ++i)      ASSERT_FLOAT_EQ(vals[i], S[r][cols[i]]);    MatRestoreRow(params.getSchurComplement(), r, &ncols, &cols, &vals);  }}

TEST(RMSEstimatorSingle, TestRMSEstimatorSetTime){    float sinewave[10000];    float out[10000];    float out2[10000];    for (unsigned i = 0; i < 10000; ++i)    {        sinewave[i] = sinf((6000 * M_PI * i)/10000); // 3000Hz sinewave at 44100    }    RMSEstimator * rms = RMSEstimatorInit(0.01, 10000);    RMSEstimator * rms2 = RMSEstimatorInit(0.05, 10000);    RMSEstimatorSetAvgTime(rms2, 0.01);    RMSEstimatorProcess(rms, out, sinewave, 10000);    RMSEstimatorProcess(rms2, out2, sinewave, 10000);    RMSEstimatorFree(rms);    RMSEstimatorFree(rms2);    for (unsigned i = 250; i < 10000; ++i)    {        ASSERT_FLOAT_EQ(out[i], out2[i]);    }}

TEST (WindowFunctionTest, AllTemporalWindowsAreSymmetricalAndRangeFrom0To1) {  KeyFinder::WindowFunction win;  unsigned int evenWidth = 24;  unsigned int oddWidth = 25;  for (unsigned int w = 0; w < 6; w++) {    KeyFinder::temporal_window_t type;    if (w % 3 == 0) type = KeyFinder::WINDOW_HANN;    else if (w % 3 == 1) type = KeyFinder::WINDOW_HAMMING;    else type = KeyFinder::WINDOW_BLACKMAN;    unsigned int width;    if (w % 2 == 0) width = evenWidth;    else width = oddWidth;    ASSERT_NEAR(0.0, win.window(type,         0, width), 0.1);    ASSERT_NEAR(1.0, win.window(type, width / 2, width), 0.1);    ASSERT_NEAR(0.0, win.window(type, width - 1, width), 0.1);    for (unsigned int n = 0; n < width / 2; n++) {      ASSERT_FLOAT_EQ(win.window(type, n, width), win.window(type, width - 1 - n, width));    }  }}

TEST(PanLawSingle, TestLinearPan){    float left = 0.0;    float right = 0.0;    linear_pan(0, &left, &right);    ASSERT_FLOAT_EQ(1.0, left);    ASSERT_FLOAT_EQ(0.0, right);        linear_pan(0.5, &left, &right);    ASSERT_FLOAT_EQ(0.5, left);    ASSERT_FLOAT_EQ(0.5, right);        linear_pan(1.0, &left, &right);    ASSERT_FLOAT_EQ(0.0, left);    ASSERT_FLOAT_EQ(1.0, right);}

TEST(RMDCuTests, deviceImageCopyFloat){  rmd::test::Dataset dataset;  if(!dataset.loadPathFromEnv())  {    FAIL() << "could not retrieve dataset path from the environment variable '"           << rmd::test::Dataset::getDataPathEnvVar();  }  cv::Mat img;  if(!dataset.readImage(img, "scene_000.png"))  {    FAIL() << "could not could not load test image from dataset";  }  cv::Mat img_flt;  img.convertTo(img_flt, CV_32F, 1./255.);  const size_t w = img_flt.cols;  const size_t h = img_flt.rows;  // upload data to gpu memory  rmd::DeviceImage<float> in_img(w, h);  in_img.setDevData(reinterpret_cast<float*>(img_flt.data));  // create copy on device  rmd::DeviceImage<float> out_img(w, h);  rmd::copy(in_img, out_img);  float * cu_img = new float[w*h];  out_img.getDevData(cu_img);  for(size_t y=0; y<h; ++y)  {    for(size_t x=0; x<w; ++x)    {      ASSERT_FLOAT_EQ(img_flt.at<float>(y, x), cu_img[y*w+x]);    }  }  delete cu_img;}

TEST_F(CProfileTest, ReadTest){    m_profile.SetUseCurrentDirectory(true);    ASSERT_TRUE(m_profile.Init()); // load colobot.ini file    std::string result;    ASSERT_TRUE(m_profile.GetStringProperty("test_string", "string_value", result));    ASSERT_STREQ("Hello world", result.c_str());    int int_value;    ASSERT_TRUE(m_profile.GetIntProperty("test_int", "int_value", int_value));    ASSERT_EQ(42, int_value);    float float_value;    ASSERT_TRUE(m_profile.GetFloatProperty("test_float", "float_value", float_value));    ASSERT_FLOAT_EQ(1.5, float_value);    std::vector<std::string> list;    list = m_profile.GetSection("test_multi", "entry");    ASSERT_EQ(5u, list.size());}

TEST(util, crc) {	ASSERT_EQ(4, efiRound(4.4, 1));	ASSERT_FLOAT_EQ(1.2, efiRound(1.2345, 0.1));	print("*************************************** testCrc/r/n");	const char * A = "A";	ASSERT_EQ( 168,  calc_crc((const crc_t *) A, 1)) << "crc8";	uint32_t c = crc32(A, 1);	printf("crc32(A)=%x/r/n", c);	assertEqualsM("crc32 1", 0xd3d99e8b, c);	const char * line = "AbcDEFGF";	c = crc32(line, 8);	printf("crc32(line)=%x/r/n", c);	assertEqualsM("crc32 line", 0x4775a7b1, c);	c = crc32(line, 1);	c = crc32inc(line + 1, c, 8 - 1);	assertEqualsM("crc32 line inc", 0x4775a7b1, c);}