TEST_F(BodyTest, RotatingSerializationSuccess) {
EXPECT_FALSE(rotating_body_.is_massless());
EXPECT_FALSE(rotating_body_.is_oblate());
serialization::Body message;
RotatingBody<World> const* cast_rotating_body;
rotating_body_.WriteToMessage(&message);
EXPECT_TRUE(message.has_massive_body());
EXPECT_FALSE(message.has_massless_body());
EXPECT_TRUE(message.massive_body().HasExtension(
serialization::RotatingBody::rotating_body));
EXPECT_EQ(17, message.massive_body().gravitational_parameter().magnitude());
serialization::RotatingBody const rotating_body_extension =
message.massive_body().GetExtension(
serialization::RotatingBody::rotating_body);
EXPECT_EQ(3, rotating_body_extension.reference_angle().magnitude());
EXPECT_EQ(4,
rotating_body_extension.reference_instant().scalar().magnitude());
EXPECT_EQ(angular_velocity_,
AngularVelocity<World>::ReadFromMessage(
rotating_body_extension.angular_velocity()));
// Dispatching from |MassiveBody|.
not_null<std::unique_ptr<MassiveBody const>> const massive_body =
MassiveBody::ReadFromMessage(message);
EXPECT_EQ(rotating_body_.gravitational_parameter(),
massive_body->gravitational_parameter());
cast_rotating_body = dynamic_cast<RotatingBody<World> const*>(&*massive_body);
EXPECT_THAT(cast_rotating_body, NotNull());
EXPECT_EQ(rotating_body_.gravitational_parameter(),
cast_rotating_body->gravitational_parameter());
EXPECT_EQ(rotating_body_.angular_velocity(),
cast_rotating_body->angular_velocity());
EXPECT_EQ(rotating_body_.AngleAt(Instant()),
cast_rotating_body->AngleAt(Instant()));
// Dispatching from |Body|.
not_null<std::unique_ptr<Body const>> const body =
Body::ReadFromMessage(message);
cast_rotating_body = dynamic_cast<RotatingBody<World> const*>(&*body);
EXPECT_THAT(cast_rotating_body, NotNull());
EXPECT_EQ(rotating_body_.gravitational_parameter(),
cast_rotating_body->gravitational_parameter());
EXPECT_EQ(rotating_body_.angular_velocity(),
cast_rotating_body->angular_velocity());
EXPECT_EQ(rotating_body_.AngleAt(Instant()),
cast_rotating_body->AngleAt(Instant()));
}
not_null<std::unique_ptr<RotatingBody<Frame>>>
RotatingBody<Frame>::ReadFromMessage(
serialization::RotatingBody const& message,
MassiveBody::Parameters const& massive_body_parameters) {
// For pre-Buffon compatibility, build a point mass.
Parameters parameters(
message.has_mean_radius()
? Length::ReadFromMessage(message.mean_radius())
: Length(),
Angle::ReadFromMessage(message.reference_angle()),
Instant::ReadFromMessage(message.reference_instant()),
AngularVelocity<Frame>::ReadFromMessage(
message.angular_velocity()));
if (message.HasExtension(serialization::OblateBody::extension)) {
serialization::OblateBody const& extension =
message.GetExtension(serialization::OblateBody::extension);
return OblateBody<Frame>::ReadFromMessage(extension,
massive_body_parameters,
parameters);
} else {
return std::make_unique<RotatingBody<Frame>>(massive_body_parameters,
parameters);
}
}