void MoveOrdererTest::test_order() { QFETCH(ChessBoard, board); QFETCH(bool, has_hash_move); QFETCH(SearchResult, entry); QFETCH(bool, has_killer_move); QFETCH(Move, killer_move); QFETCH(vector<Move>, moves); QFETCH(vector<Move>, ordered_moves); SearchContext context; context.search_depth = 1; context.board = board; if (has_hash_move) { context.put(0, entry); } if (has_killer_move) { context.killers.resize(1); context.killers[0][0] = killer_move; } SearchState state; state.depth = 1; m_orderer.order_moves(entry, state, &context, &moves); QASSERT_THAT(moves, ElementsAreArray(ordered_moves)); }
TEST_F(LocalConnectionTest, send_binary) { const auto kExpected = ElementsAreArray(&bytes_[0], bytes_.size()); Connection::Ptr conn(LocalConnection::New()); Connection::Ptr other(((LocalConnection*) conn.get())->other()); ConnectionDelegateMock mock; EXPECT_CALL(mock, OnBinary(other.get(), kExpected)); other->BindDelegate(&mock); conn->SendBinary(bytes_); }
TEST_F(SolarSystemTest, Clear) { solar_system_.Initialize( SOLUTION_DIR / "astronomy" / "gravity_model.proto.txt", SOLUTION_DIR / "astronomy" / "initial_state_jd_2433282_500000000.proto.txt"); solar_system_.RemoveMassiveBody("Io"); solar_system_.RemoveOblateness("Sun"); EXPECT_THAT(solar_system_.names(), ElementsAreArray({"Ariel", "Callisto", "Ceres", "Charon", "Deimos", "Dione", "Earth", "Enceladus", "Eris", "Europa", "Ganymede", "Iapetus", "Jupiter", "Mars", "Mercury", "Mimas", "Miranda", "Moon", "Neptune", "Oberon", "Phobos", "Pluto", "Rhea", "Saturn", "Sun", "Tethys", "Titan", "Titania", "Triton", "Umbriel", "Uranus", "Venus", "Vesta"})); auto const& sun_initial_state = solar_system_.initial_state_message("Sun"); EXPECT_EQ("+1.309126697236264E+05 km", sun_initial_state.x()); EXPECT_EQ("-7.799754996220354E-03 km/s", sun_initial_state.vx()); auto const& sun_gravity_model = solar_system_.gravity_model_message("Sun"); EXPECT_FALSE(sun_gravity_model.has_axis_right_ascension()); EXPECT_FALSE(sun_gravity_model.has_axis_declination()); }
TEST_F(PullSerializerTest, SerializationSizes) { auto trajectory = BuildTrajectory(); pull_serializer_->Start(std::move(trajectory)); std::vector<std::int64_t> actual_sizes; std::vector<std::int64_t> expected_sizes(53, kChunkSize); expected_sizes.push_back(53); for (;;) { Bytes const bytes = pull_serializer_->Pull(); if (bytes.size == 0) { break; } actual_sizes.push_back(bytes.size); } EXPECT_THAT(actual_sizes, ElementsAreArray(expected_sizes)); }
TEST_F(EmbeddedExplicitRungeKuttaNyströmIntegratorTest, Restart) { AdaptiveStepSizeIntegrator<ODE> const& integrator = EmbeddedExplicitRungeKuttaNyströmIntegrator< methods::DormandالمكاوىPrince1986RKN434FM, Length>(); Length const x_initial = 1 * Metre; Speed const v_initial = 0 * Metre / Second; Speed const v_amplitude = 1 * Metre / Second; Time const period = 2 * π * Second; AngularFrequency const ω = 1 * Radian / Second; Instant const t_initial; Time const duration = 10 * period; Length const length_tolerance = 1 * Milli(Metre); Speed const speed_tolerance = 1 * Milli(Metre) / Second; // The number of steps if no step limit is set. std::int64_t const steps_forward = 132; auto const step_size_callback = [](bool tolerable) {}; std::vector<ODE::SystemState> solution1; { ODE harmonic_oscillator; harmonic_oscillator.compute_acceleration = std::bind(ComputeHarmonicOscillatorAcceleration1D, _1, _2, _3, /*evaluations=*/nullptr); IntegrationProblem<ODE> problem; problem.equation = harmonic_oscillator; problem.initial_state = {{x_initial}, {v_initial}, t_initial}; auto const append_state = [&solution1](ODE::SystemState const& state) { solution1.push_back(state); }; AdaptiveStepSizeIntegrator<ODE>::Parameters const parameters( /*first_time_step=*/duration, /*safety_factor=*/0.9, /*max_steps=*/std::numeric_limits<std::int64_t>::max(), /*last_step_is_exact=*/false); auto const tolerance_to_error_ratio = std::bind(HarmonicOscillatorToleranceRatio, _1, _2, length_tolerance, speed_tolerance, step_size_callback); auto const instance = integrator.NewInstance(problem, append_state, tolerance_to_error_ratio, parameters); auto outcome = instance->Solve(t_initial + duration); EXPECT_EQ(termination_condition::Done, outcome.error()); // Check that the time step has been updated. EXPECT_EQ(131, solution1.size()); EXPECT_THAT( solution1[solution1.size() - 1].time.value - solution1[solution1.size() - 2].time.value, AlmostEquals(0.509'363'975'335'290'320 * Second, 0)); // Restart the integration. outcome = instance->Solve(t_initial + 2.0 * duration); EXPECT_EQ(termination_condition::Done, outcome.error()); // Check that the time step has been updated again. EXPECT_EQ(261, solution1.size()); EXPECT_THAT( solution1[solution1.size() - 1].time.value - solution1[solution1.size() - 2].time.value, AlmostEquals(0.506'410'259'195'249'068 * Second, 0)); } // Do it again in one call to |Solve| and check associativity. std::vector<ODE::SystemState> solution2; { ODE harmonic_oscillator; harmonic_oscillator.compute_acceleration = std::bind(ComputeHarmonicOscillatorAcceleration1D, _1, _2, _3, /*evaluations=*/nullptr); IntegrationProblem<ODE> problem; problem.equation = harmonic_oscillator; problem.initial_state = {{x_initial}, {v_initial}, t_initial}; auto const append_state = [&solution2](ODE::SystemState const& state) { solution2.push_back(state); }; AdaptiveStepSizeIntegrator<ODE>::Parameters const parameters( /*first_time_step=*/duration, /*safety_factor=*/0.9, /*max_steps=*/std::numeric_limits<std::int64_t>::max(), /*last_step_is_exact=*/false); auto const tolerance_to_error_ratio = std::bind(HarmonicOscillatorToleranceRatio, _1, _2, length_tolerance, speed_tolerance, step_size_callback); auto const instance = integrator.NewInstance(problem, append_state, tolerance_to_error_ratio, parameters); auto outcome = instance->Solve(t_initial + 2.0 * duration); EXPECT_EQ(termination_condition::Done, outcome.error()); } EXPECT_THAT(solution2, ElementsAreArray(solution1)); }
TEST_F(SolarSystemTest, RealSolarSystem) { solar_system_.Initialize( SOLUTION_DIR / "astronomy" / "gravity_model.proto.txt", SOLUTION_DIR / "astronomy" / "initial_state_jd_2433282_500000000.proto.txt"); EXPECT_EQ(Instant() - 50 * 365.25 * Day, solar_system_.epoch()); EXPECT_THAT(solar_system_.names(), ElementsAreArray({"Ariel", "Callisto", "Ceres", "Charon", "Deimos", "Dione", "Earth", "Enceladus", "Eris", "Europa", "Ganymede", "Iapetus", "Io", "Jupiter", "Mars", "Mercury", "Mimas", "Miranda", "Moon", "Neptune", "Oberon", "Phobos", "Pluto", "Rhea", "Saturn", "Sun", "Tethys", "Titan", "Titania", "Triton", "Umbriel", "Uranus", "Venus", "Vesta"})); EXPECT_EQ(1, solar_system_.index("Callisto")); EXPECT_EQ(32, solar_system_.index("Venus")); auto const ephemeris = solar_system_.MakeEphemeris( /*fitting_tolerance=*/1 * Metre, Ephemeris<ICRFJ2000Equator>::FixedStepParameters( integrators::McLachlanAtela1992Order4Optimal< Position<ICRFJ2000Equator>>(), /*step=*/1 * Second)); auto const earth = solar_system_.massive_body(*ephemeris, "Earth"); EXPECT_LT(RelativeError(5.97258 * Yotta(Kilogram), earth->mass()), 6E-9); auto const& earth_trajectory = solar_system_.trajectory(*ephemeris, "Earth"); EXPECT_TRUE(earth_trajectory.empty()); auto const& sun_initial_state = solar_system_.initial_state_message("Sun"); EXPECT_EQ("+1.309126697236264E+05 km", sun_initial_state.x()); EXPECT_EQ("-7.799754996220354E-03 km/s", sun_initial_state.vx()); auto const& sun_gravity_model = solar_system_.gravity_model_message("Sun"); EXPECT_EQ("286.13 deg", sun_gravity_model.axis_right_ascension()); EXPECT_EQ("63.87 deg", sun_gravity_model.axis_declination()); }