TEST_F(VectorTest, DefaultEntriesTest) { EXPECT_DOUBLE_EQ(0, emptyVector[0]); EXPECT_DOUBLE_EQ(0, emptyVector[1]); EXPECT_DOUBLE_EQ(0, emptyVector[2]); }
TEST_F(VectorTest, SumTest) { EXPECT_DOUBLE_EQ(6.6, vDouble1.sum()); EXPECT_DOUBLE_EQ(-0.9, vDouble2.sum()); EXPECT_EQ(6, vInt1.sum()); EXPECT_EQ(-1, vInt2.sum()); }
void expectEqTestRequest(const TestRequest& a, const TestRequest& b) { EXPECT_EQ(a.key().fullKey(), b.key().fullKey()); EXPECT_EQ(a.testBool(), b.testBool()); EXPECT_EQ(a.testChar(), b.testChar()); EXPECT_EQ(a.testEnum(), b.testEnum()); EXPECT_EQ(a.testInt8(), b.testInt8()); EXPECT_EQ(a.testInt16(), b.testInt16()); EXPECT_EQ(a.testInt32(), b.testInt32()); EXPECT_EQ(a.testInt64(), b.testInt64()); EXPECT_EQ(a.testUInt8(), b.testUInt8()); EXPECT_EQ(a.testUInt16(), b.testUInt16()); EXPECT_EQ(a.testUInt32(), b.testUInt32()); EXPECT_EQ(a.testUInt64(), b.testUInt64()); EXPECT_FLOAT_EQ(a.testFloat(), b.testFloat()); EXPECT_DOUBLE_EQ(a.testDouble(), b.testDouble()); EXPECT_EQ(a.testShortString(), b.testShortString()); EXPECT_EQ(a.testLongString(), b.testLongString()); EXPECT_EQ( coalesceAndGetRange(const_cast<folly::IOBuf&>(a.testIobuf())), coalesceAndGetRange(const_cast<folly::IOBuf&>(b.testIobuf()))); // Mixed-in structure EXPECT_EQ(a.int32Member(), b.int32Member()); EXPECT_EQ(a.stringMember(), b.stringMember()); EXPECT_EQ(a.enumMember(), b.enumMember()); expectEqSimpleStruct(a.asBase(), b.asBase()); // Member structure expectEqSimpleStruct(a.testStruct(), b.testStruct()); EXPECT_EQ(a.testList(), b.testList()); EXPECT_EQ(a.testNestedVec(), b.testNestedVec()); EXPECT_EQ(a.testEnumVec(), b.testEnumVec()); EXPECT_EQ(a.testUMap(), b.testUMap()); EXPECT_EQ(a.testMap(), b.testMap()); EXPECT_EQ(a.testF14FastMap(), b.testF14FastMap()); EXPECT_EQ(a.testF14NodeMap(), b.testF14NodeMap()); EXPECT_EQ(a.testF14ValueMap(), b.testF14ValueMap()); EXPECT_EQ(a.testF14VectorMap(), b.testF14VectorMap()); EXPECT_EQ(a.testComplexMap(), b.testComplexMap()); EXPECT_EQ(a.testUSet(), b.testUSet()); EXPECT_EQ(a.testSet(), b.testSet()); EXPECT_EQ(a.testF14FastSet(), b.testF14FastSet()); EXPECT_EQ(a.testF14NodeSet(), b.testF14NodeSet()); EXPECT_EQ(a.testF14ValueSet(), b.testF14ValueSet()); EXPECT_EQ(a.testF14VectorSet(), b.testF14VectorSet()); EXPECT_EQ(a.testOptionalString(), b.testOptionalString()); compareOptionalIobuf(a.testOptionalIobuf(), b.testOptionalIobuf()); EXPECT_EQ(a.testType().name, b.testType().name); EXPECT_EQ(a.testType().points, b.testType().points); EXPECT_EQ(a.testOptionalBool(), b.testOptionalBool()); EXPECT_EQ(a.testOptionalVec(), b.testOptionalVec()); }
TEST_F(VectorTest, VectorCopyDoubleAndInt) { Vector copyDoubleToDouble1(vDouble1); VectorInt copyIntToInt1(vInt1); Vector copyIntToDouble1(vInt2); VectorInt copyDoubleToInt1(vDouble2); Vector copyDoubleToDouble2 = vDouble1; VectorInt copyIntToInt2 = vInt1; Vector copyIntToDouble2 = vInt2; VectorInt copyDoubleToInt2 = vDouble2; EXPECT_DOUBLE_EQ(1.1, copyDoubleToDouble1[0]); EXPECT_DOUBLE_EQ(2.2, copyDoubleToDouble1[1]); EXPECT_DOUBLE_EQ(3.3, copyDoubleToDouble1[2]); EXPECT_EQ(1, copyIntToInt1[0]); EXPECT_EQ(2, copyIntToInt1[1]); EXPECT_EQ(3, copyIntToInt1[2]); EXPECT_DOUBLE_EQ(-2.0, copyIntToDouble1[0]); EXPECT_DOUBLE_EQ( 1.0, copyIntToDouble1[1]); EXPECT_DOUBLE_EQ( 0.0, copyIntToDouble1[2]); EXPECT_EQ(-2, copyDoubleToInt1[0]); EXPECT_EQ( 1, copyDoubleToInt1[1]); EXPECT_EQ( 0, copyDoubleToInt1[2]); EXPECT_DOUBLE_EQ(1.1, copyDoubleToDouble2[0]); EXPECT_DOUBLE_EQ(2.2, copyDoubleToDouble2[1]); EXPECT_DOUBLE_EQ(3.3, copyDoubleToDouble2[2]); EXPECT_EQ(1, copyIntToInt2[0]); EXPECT_EQ(2, copyIntToInt2[1]); EXPECT_EQ(3, copyIntToInt2[2]); EXPECT_DOUBLE_EQ(-2.0, copyIntToDouble2[0]); EXPECT_DOUBLE_EQ( 1.0, copyIntToDouble2[1]); EXPECT_DOUBLE_EQ( 0.0, copyIntToDouble2[2]); EXPECT_EQ(-2, copyDoubleToInt2[0]); EXPECT_EQ( 1, copyDoubleToInt2[1]); EXPECT_EQ( 0, copyDoubleToInt2[2]); }
TEST_F(Zone_Test, absolute_height) { zone->addHeightRangeQuick(1.0, -1.0, 2.0, 5.0, 6.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -10.0, 0.0), VECTOR_UP), 0.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -2.0, 0.0), VECTOR_UP), 0.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -1.0, 0.0), VECTOR_UP), 0.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, -0.5, 0.0), VECTOR_UP), 1.0 / 6.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 0.0, 0.0), VECTOR_UP), 1.0 / 3.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 0.5, 0.0), VECTOR_UP), 0.5); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 2.0, 0.0), VECTOR_UP), 1.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 2.1, 0.0), VECTOR_UP), 1.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 3.5, 0.0), VECTOR_UP), 1.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 4.9, 0.0), VECTOR_UP), 1.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 5.0, 0.0), VECTOR_UP), 1.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 5.2, 0.0), VECTOR_UP), 0.8); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 5.7, 0.0), VECTOR_UP), 0.3); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 6.0, 0.0), VECTOR_UP), 0.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 15.0, 0.0), VECTOR_UP), 0.0); EXPECT_DOUBLE_EQ(zone->getValue(Vector3(0.0, 150.0, 0.0), VECTOR_UP), 0.0); }
TEST_F(test_dvector, reallocate) { dvector v(1, 4); v(1) = 0.5; v(2) = 1.5; v(3) = 2.5; v(4) = -4.5; EXPECT_DOUBLE_EQ(1, v.indexmin()); EXPECT_DOUBLE_EQ(4, v.indexmax()); EXPECT_DOUBLE_EQ(4, v.size()); v.reallocate(2.5); EXPECT_DOUBLE_EQ(1, v.indexmin()); EXPECT_DOUBLE_EQ(10, v.indexmax()); EXPECT_DOUBLE_EQ(10, v.size()); EXPECT_DOUBLE_EQ(0.5, v(1)); EXPECT_DOUBLE_EQ(1.5, v(2)); EXPECT_DOUBLE_EQ(2.5, v(3)); EXPECT_DOUBLE_EQ(-4.5, v(4)); EXPECT_DOUBLE_EQ(0, v(5)); EXPECT_DOUBLE_EQ(0, v(6)); EXPECT_DOUBLE_EQ(0, v(7)); EXPECT_DOUBLE_EQ(0, v(8)); EXPECT_DOUBLE_EQ(0, v(9)); EXPECT_DOUBLE_EQ(0, v(10)); v.reallocate(0.2); EXPECT_DOUBLE_EQ(1, v.indexmin()); EXPECT_DOUBLE_EQ(2, v.indexmax()); EXPECT_DOUBLE_EQ(2, v.size()); EXPECT_DOUBLE_EQ(0.5, v(1)); EXPECT_DOUBLE_EQ(1.5, v(2)); }
/* Test the method 'splitAt'*/ TEST_F(PositionVectorTest, test_method_splitAt) { PositionVector vec; vec.push_back(Position(0,0)); vec.push_back(Position(2,0)); vec.push_back(Position(5,0)); double smallDiff = POSITION_EPS / 2; std::pair<PositionVector, PositionVector> result; // split in first segment result = vec.splitAt(1); EXPECT_EQ(2, (int)result.first.size()); EXPECT_DOUBLE_EQ(0., result.first[0].x()); EXPECT_DOUBLE_EQ(1., result.first[1].x()); EXPECT_EQ(3, (int)result.second.size()); EXPECT_DOUBLE_EQ(1., result.second[0].x()); EXPECT_DOUBLE_EQ(2., result.second[1].x()); EXPECT_DOUBLE_EQ(5., result.second[2].x()); // split in second segment result = vec.splitAt(4); EXPECT_EQ(3, (int)result.first.size()); EXPECT_DOUBLE_EQ(0., result.first[0].x()); EXPECT_DOUBLE_EQ(2., result.first[1].x()); EXPECT_DOUBLE_EQ(4., result.first[2].x()); EXPECT_EQ(2, (int)result.second.size()); EXPECT_DOUBLE_EQ(4., result.second[0].x()); EXPECT_DOUBLE_EQ(5., result.second[1].x()); // split close before inner point result = vec.splitAt(2 - smallDiff); EXPECT_EQ(2, (int)result.first.size()); EXPECT_DOUBLE_EQ(0., result.first[0].x()); EXPECT_DOUBLE_EQ(2., result.first[1].x()); EXPECT_EQ(2, (int)result.second.size()); EXPECT_DOUBLE_EQ(2., result.second[0].x()); EXPECT_DOUBLE_EQ(5., result.second[1].x()); // split close after inner point result = vec.splitAt(2 + smallDiff); EXPECT_EQ(2, (int)result.first.size()); EXPECT_DOUBLE_EQ(0., result.first[0].x()); EXPECT_DOUBLE_EQ(2., result.first[1].x()); EXPECT_EQ(2, (int)result.second.size()); EXPECT_DOUBLE_EQ(2., result.second[0].x()); EXPECT_DOUBLE_EQ(5., result.second[1].x()); // catch a bug vec.push_back(Position(6,0)); vec.push_back(Position(8,0)); // split at inner point result = vec.splitAt(5); EXPECT_EQ(3, (int)result.first.size()); EXPECT_DOUBLE_EQ(0., result.first[0].x()); EXPECT_DOUBLE_EQ(2., result.first[1].x()); EXPECT_DOUBLE_EQ(5., result.first[2].x()); EXPECT_EQ(3, (int)result.second.size()); EXPECT_DOUBLE_EQ(5., result.second[0].x()); EXPECT_DOUBLE_EQ(6., result.second[1].x()); EXPECT_DOUBLE_EQ(8., result.second[2].x()); // split short vector PositionVector vec2; vec2.push_back(Position(0,0)); vec2.push_back(Position(2,0)); result = vec2.splitAt(1); EXPECT_EQ(2, (int)result.first.size()); EXPECT_DOUBLE_EQ(0., result.first[0].x()); EXPECT_DOUBLE_EQ(1., result.first[1].x()); EXPECT_EQ(2, (int)result.second.size()); EXPECT_DOUBLE_EQ(1., result.second[0].x()); EXPECT_DOUBLE_EQ(2. ,result.second[1].x()); // split very short vector PositionVector vec3; vec3.push_back(Position(0,0)); vec3.push_back(Position(POSITION_EPS,0)); // supress expected warning MsgHandler::getWarningInstance()->removeRetriever(&OutputDevice::getDevice("stderr")); result = vec3.splitAt(smallDiff); MsgHandler::getWarningInstance()->addRetriever(&OutputDevice::getDevice("stderr")); EXPECT_EQ(2, (int)result.first.size()); EXPECT_DOUBLE_EQ(0., result.first[0].x()); EXPECT_DOUBLE_EQ(smallDiff, result.first[1].x()); EXPECT_EQ(2, (int)result.second.size()); EXPECT_DOUBLE_EQ(smallDiff, result.second[0].x()); EXPECT_DOUBLE_EQ(POSITION_EPS, result.second[1].x()); }
TEST(VectorTest, Angle) { Vector_d p1(4, 4); EXPECT_DOUBLE_EQ(M_PI / 4.0, p1.angle()); }
TEST_F(SettingsTest, AddSettingDouble) { settings.add("test_setting", "1234567.890"); EXPECT_DOUBLE_EQ(double(1234567.89), settings.get<double>("test_setting")); }
/* Test the method 'getPolygonCenter'.*/ TEST_F(PositionVectorTest, test_method_getPolygonCenter) { Position pos = vectorPolygon->getPolygonCenter(); EXPECT_DOUBLE_EQ(2, pos.x()); EXPECT_DOUBLE_EQ(1.6, pos.y()); Position pos2 = vectorLine->getPolygonCenter(); }
TEST_F(SettingsTest, AddSettingRatio) { settings.add("test_setting", "1.618"); EXPECT_DOUBLE_EQ(Ratio(0.01618), settings.get<Ratio>("test_setting")) << "With ratios, the input is interpreted in percentages."; }
TEST_F(SettingsTest, AddSettingTemperature) { settings.add("test_setting", "245.5"); EXPECT_DOUBLE_EQ(Temperature(245.5), settings.get<Temperature>("test_setting")); }
//---------------------------------------------------------------------------// // Test distance to next surface or vertex for various directions TEST_F(FluDAGTest, GFireGoodPropStep) { // std::cout << "Calling g_fire. Start in middle of leftmost cube" << std::endl; oldReg = 2; point[2] = 5.0; // Set prepStep to something more realistic than 0.0 propStep = 1e38; // +z direction dir[2] = 1.0; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); std::cout << "newReg is " << newReg << std::endl; // Start in middle of 10x10x10 cube, expect 10/2 to be dist. to next surface EXPECT_EQ(5.0, retStep); // -z direction dir[2] = -dir[2]; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_EQ(5.0, retStep); // +y direction dir[2] = 0.0; dir[1] = 1.0; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_EQ(5.0, retStep); // -y direction dir[1] = -dir[1]; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_EQ(5.0, retStep); // +x direction dir[1] = 0.0; dir[0] = 1.0; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_EQ(5.0, retStep); // -x direction dir[0] = -dir[0]; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_EQ(5.0, retStep); // +++ dir[0] = +dir_norm; dir[1] = +dir_norm; dir[2] = +dir_norm; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_NEAR(8.660254, retStep, 1e-6); // ++- // Not Lost Particle! dir[0] = +dir_norm; dir[1] = +dir_norm; dir[2] = -dir_norm; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_NEAR(8.660254, retStep, 1e-6); // +-+ dir[0] = +dir_norm; dir[1] = -dir_norm; dir[2] = +dir_norm; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_NEAR(8.660254, retStep, 1e-6); // +-- // Not Lost Particle! dir[0] = +dir_norm; dir[1] = -dir_norm; dir[2] = -dir_norm; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_NEAR(8.660254, retStep, 1e-6); // -++ dir[0] = -dir_norm; dir[1] = +dir_norm; dir[2] = +dir_norm; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_DOUBLE_EQ(5.0/dir_norm, retStep); // -+- // Not Lost Particle! dir[0] = -dir_norm; dir[1] = +dir_norm; dir[2] = -dir_norm; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_DOUBLE_EQ(5.0/dir_norm, retStep); // --+ dir[0] = -dir_norm; dir[1] = -dir_norm; dir[2] = +dir_norm; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_DOUBLE_EQ(5.0/dir_norm, retStep); // --- // Not Lost Particle! dir[0] = -dir_norm; dir[1] = -dir_norm; dir[2] = -dir_norm; g_fire(oldReg, point, dir, propStep, retStep, safety, newReg); EXPECT_DOUBLE_EQ(5.0/dir_norm, retStep); }
TEST_F(VectorTest, ProdTest) { EXPECT_DOUBLE_EQ(7.986, vDouble1.prod()); EXPECT_DOUBLE_EQ(0.345, vDouble2.prod()); EXPECT_EQ(6, vInt1.prod()); EXPECT_EQ(0, vInt2.prod()); }
// 检查浮点数 TEST(casename, testname5) { EXPECT_FLOAT_EQ(expected, actual); EXPECT_DOUBLE_EQ(expected, actual); }
TEST_F(KeyframeEffectModelTest, EvenlyDistributed3) { KeyframeEffectModel::KeyframeVector keyframes(12); keyframes[0] = Keyframe::create(); keyframes[0]->setOffset(0); keyframes[1] = Keyframe::create(); keyframes[2] = Keyframe::create(); keyframes[3] = Keyframe::create(); keyframes[4] = Keyframe::create(); keyframes[4]->setOffset(0.5); keyframes[5] = Keyframe::create(); keyframes[6] = Keyframe::create(); keyframes[7] = Keyframe::create(); keyframes[7]->setOffset(0.8); keyframes[8] = Keyframe::create(); keyframes[9] = Keyframe::create(); keyframes[10] = Keyframe::create(); keyframes[11] = Keyframe::create(); const KeyframeVector result = normalizedKeyframes(keyframes); EXPECT_EQ(12U, result.size()); EXPECT_DOUBLE_EQ(0.0, result[0]->offset()); EXPECT_DOUBLE_EQ(0.125, result[1]->offset()); EXPECT_DOUBLE_EQ(0.25, result[2]->offset()); EXPECT_DOUBLE_EQ(0.375, result[3]->offset()); EXPECT_DOUBLE_EQ(0.5, result[4]->offset()); EXPECT_DOUBLE_EQ(0.6, result[5]->offset()); EXPECT_DOUBLE_EQ(0.7, result[6]->offset()); EXPECT_DOUBLE_EQ(0.8, result[7]->offset()); EXPECT_DOUBLE_EQ(0.85, result[8]->offset()); EXPECT_DOUBLE_EQ(0.9, result[9]->offset()); EXPECT_DOUBLE_EQ(0.95, result[10]->offset()); EXPECT_DOUBLE_EQ(1.0, result[11]->offset()); }
TEST(evaluate_baselines, cpu_gpu) { oskar_Mem *u, *v, *w, *uu, *vv, *ww; oskar_Mem *u_gpu, *v_gpu, *w_gpu, *uu_gpu, *vv_gpu, *ww_gpu; int num_baselines, num_stations = 50, status = 0, type, location; double *u_, *v_, *w_, *uu_, *vv_, *ww_; num_baselines = num_stations * (num_stations - 1) / 2; type = OSKAR_DOUBLE; // Allocate host memory. location = OSKAR_CPU; u = oskar_mem_create(type, location, num_stations, &status); v = oskar_mem_create(type, location, num_stations, &status); w = oskar_mem_create(type, location, num_stations, &status); uu = oskar_mem_create(type, location, num_baselines, &status); vv = oskar_mem_create(type, location, num_baselines, &status); ww = oskar_mem_create(type, location, num_baselines, &status); u_ = oskar_mem_double(u, &status); v_ = oskar_mem_double(v, &status); w_ = oskar_mem_double(w, &status); uu_ = oskar_mem_double(uu, &status); vv_ = oskar_mem_double(vv, &status); ww_ = oskar_mem_double(ww, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); // Fill station coordinates with test data. for (int i = 0; i < num_stations; ++i) { u_[i] = (double)(i + 1); v_[i] = (double)(i + 2); w_[i] = (double)(i + 3); } // Evaluate baseline coordinates on CPU. oskar_convert_station_uvw_to_baseline_uvw(num_stations, 0, u, v, w, 0, uu, vv, ww, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); // Check results are correct. for (int s1 = 0, b = 0; s1 < num_stations; ++s1) { for (int s2 = s1 + 1; s2 < num_stations; ++s2, ++b) { EXPECT_DOUBLE_EQ(u_[s2] - u_[s1], uu_[b]); EXPECT_DOUBLE_EQ(v_[s2] - v_[s1], vv_[b]); EXPECT_DOUBLE_EQ(w_[s2] - w_[s1], ww_[b]); } } // Allocate device memory and copy input data. #ifdef OSKAR_HAVE_CUDA location = OSKAR_GPU; #endif u_gpu = oskar_mem_create_copy(u, location, &status); v_gpu = oskar_mem_create_copy(v, location, &status); w_gpu = oskar_mem_create_copy(w, location, &status); uu_gpu = oskar_mem_create(type, location, num_baselines, &status); vv_gpu = oskar_mem_create(type, location, num_baselines, &status); ww_gpu = oskar_mem_create(type, location, num_baselines, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); // Evaluate baseline coordinates on device. oskar_convert_station_uvw_to_baseline_uvw(num_stations, 0, u_gpu, v_gpu, w_gpu, 0, uu_gpu, vv_gpu, ww_gpu, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); // Check results are consistent. double max_, avg; oskar_mem_evaluate_relative_error(uu_gpu, uu, 0, &max_, &avg, 0, &status); ASSERT_LT(max_, 1e-12); ASSERT_LT(avg, 1e-12); oskar_mem_evaluate_relative_error(vv_gpu, vv, 0, &max_, &avg, 0, &status); ASSERT_LT(max_, 1e-12); ASSERT_LT(avg, 1e-12); oskar_mem_evaluate_relative_error(ww_gpu, ww, 0, &max_, &avg, 0, &status); ASSERT_LT(max_, 1e-12); ASSERT_LT(avg, 1e-12); // Free memory. oskar_mem_free(u, &status); oskar_mem_free(v, &status); oskar_mem_free(w, &status); oskar_mem_free(uu, &status); oskar_mem_free(vv, &status); oskar_mem_free(ww, &status); oskar_mem_free(u_gpu, &status); oskar_mem_free(v_gpu, &status); oskar_mem_free(w_gpu, &status); oskar_mem_free(uu_gpu, &status); oskar_mem_free(vv_gpu, &status); oskar_mem_free(ww_gpu, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); }
TEST_F(PublicMethodsEmbedderTest, MakeRegularDate) { v8::Isolate::Scope isolate_scope(isolate()); v8::HandleScope handle_scope(isolate()); v8::Context::Scope context_scope(GetV8Context()); bool bWrongFormat; double date; // 1968 bWrongFormat = false; date = CJS_PublicMethods::MakeRegularDate(L"06/25/1968", L"mm/dd/yyyy", &bWrongFormat); date = RoundDownDate(date); EXPECT_DOUBLE_EQ(-47865600000, date); EXPECT_FALSE(bWrongFormat); // 1968 bWrongFormat = false; date = CJS_PublicMethods::MakeRegularDate(L"25061968", L"ddmmyyyy", &bWrongFormat); date = RoundDownDate(date); EXPECT_DOUBLE_EQ(-47865600000, date); EXPECT_FALSE(bWrongFormat); // 1968 bWrongFormat = false; date = CJS_PublicMethods::MakeRegularDate(L"19680625", L"yyyymmdd", &bWrongFormat); date = RoundDownDate(date); EXPECT_DOUBLE_EQ(-47865600000, date); EXPECT_FALSE(bWrongFormat); // 1985 bWrongFormat = false; date = CJS_PublicMethods::MakeRegularDate(L"31121985", L"ddmmyyyy", &bWrongFormat); date = RoundDownDate(date); EXPECT_DOUBLE_EQ(504835200000.0, date); EXPECT_FALSE(bWrongFormat); // 2085, the other '85. bWrongFormat = false; date = CJS_PublicMethods::MakeRegularDate(L"311285", L"ddmmyy", &bWrongFormat); date = RoundDownDate(date); EXPECT_DOUBLE_EQ(3660595200000.0, date); EXPECT_FALSE(bWrongFormat); // 1995 bWrongFormat = false; date = CJS_PublicMethods::MakeRegularDate(L"01021995", L"ddmmyyyy", &bWrongFormat); date = RoundDownDate(date); EXPECT_DOUBLE_EQ(791596800000.0, date); EXPECT_FALSE(bWrongFormat); // 2095, the other '95. bWrongFormat = false; date = CJS_PublicMethods::MakeRegularDate(L"010295", L"ddmmyy", &bWrongFormat); date = RoundDownDate(date); EXPECT_DOUBLE_EQ(3947356800000.0, date); EXPECT_FALSE(bWrongFormat); // 2005 bWrongFormat = false; date = CJS_PublicMethods::MakeRegularDate(L"01022005", L"ddmmyyyy", &bWrongFormat); date = RoundDownDate(date); EXPECT_DOUBLE_EQ(1107216000000.0, date); EXPECT_FALSE(bWrongFormat); // 2005 bWrongFormat = false; date = CJS_PublicMethods::MakeRegularDate(L"010205", L"ddmmyy", &bWrongFormat); date = RoundDownDate(date); EXPECT_DOUBLE_EQ(1107216000000.0, date); EXPECT_FALSE(bWrongFormat); }
TEST_F(CueControlTest, OutroCue_SetStartEnd_ClearStartEnd) { TrackPointer pTrack = createAndLoadFakeTrack(); // Set outro start cue setCurrentSample(750.0); m_pOutroStartSet->slotSet(1); m_pOutroStartSet->slotSet(0); EXPECT_DOUBLE_EQ(750.0, m_pOutroStartPosition->get()); EXPECT_TRUE(m_pOutroStartEnabled->toBool()); EXPECT_DOUBLE_EQ(-1.0, m_pOutroEndPosition->get()); EXPECT_FALSE(m_pOutroEndEnabled->toBool()); CuePointer pCue = pTrack->findCueByType(Cue::OUTRO); EXPECT_NE(nullptr, pCue); if (pCue != nullptr) { EXPECT_DOUBLE_EQ(750.0, pCue->getPosition()); EXPECT_DOUBLE_EQ(0.0, pCue->getLength()); EXPECT_DOUBLE_EQ(Cue::MANUAL, pCue->getSource()); } // Set outro end cue setCurrentSample(1000.0); m_pOutroEndSet->slotSet(1); m_pOutroEndSet->slotSet(0); EXPECT_DOUBLE_EQ(750.0, m_pOutroStartPosition->get()); EXPECT_TRUE(m_pOutroStartEnabled->toBool()); EXPECT_DOUBLE_EQ(1000.0, m_pOutroEndPosition->get()); EXPECT_TRUE(m_pOutroEndEnabled->toBool()); pCue = pTrack->findCueByType(Cue::OUTRO); EXPECT_NE(nullptr, pCue); if (pCue != nullptr) { EXPECT_DOUBLE_EQ(750.0, pCue->getPosition()); EXPECT_DOUBLE_EQ(250.0, pCue->getLength()); EXPECT_DOUBLE_EQ(Cue::MANUAL, pCue->getSource()); } // Clear outro start cue m_pOutroStartClear->slotSet(1); m_pOutroStartClear->slotSet(0); EXPECT_DOUBLE_EQ(-1.0, m_pOutroStartPosition->get()); EXPECT_FALSE(m_pOutroStartEnabled->toBool()); EXPECT_DOUBLE_EQ(1000.0, m_pOutroEndPosition->get()); EXPECT_TRUE(m_pOutroEndEnabled->toBool()); pCue = pTrack->findCueByType(Cue::OUTRO); EXPECT_NE(nullptr, pCue); if (pCue != nullptr) { EXPECT_DOUBLE_EQ(-1.0, pCue->getPosition()); EXPECT_DOUBLE_EQ(1000.0, pCue->getLength()); EXPECT_DOUBLE_EQ(Cue::MANUAL, pCue->getSource()); } // Clear outro end cue m_pOutroEndClear->slotSet(1); m_pOutroEndClear->slotSet(0); EXPECT_DOUBLE_EQ(-1.0, m_pOutroStartPosition->get()); EXPECT_FALSE(m_pOutroStartEnabled->toBool()); EXPECT_DOUBLE_EQ(-1.0, m_pOutroEndPosition->get()); EXPECT_FALSE(m_pOutroEndEnabled->toBool()); EXPECT_EQ(nullptr, pTrack->findCueByType(Cue::OUTRO)); }