baram2584/FESADev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(cpp-object-oriented-modular-refactoring): step 3 - foundation-google-style

Browse Source
This commit is contained in:
KOKO\Mimi
2026-08-16 04:26:14 +09:00
parent 2628ed3488
commit 042edadffb
93 changed files with 3144 additions and 3175 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit/model/domain_test.cpp
+27 -27
View File
@@ -59,7 +59,7 @@ fesa::ModelDefinition makeOwnedDefinition() {
1.0,
{"models/owned.inp", 55U}}};
definition.warnings = {{
fesa::Severity::warning,
fesa::Severity::kWarning,
"ignored-output-request",
{"models/owned.inp", 70U},
"*OUTPUT",
@@ -73,17 +73,17 @@ fesa::ModelDefinition makeOwnedDefinition() {
TEST(DomainModel, ImmutableOwnershipPreservesStableOrder) {
auto definition = makeOwnedDefinition();
auto result = fesa::Domain::create(definition);
ASSERT_TRUE(result.hasValue());
ASSERT_TRUE(result.HasValue());
definition.sourcePath = "mutated.inp";
definition.sourceContentIdentity = "mutated";
definition.nodes[0].sourceId.sourceLabelText = "mutated";
definition.nodes[0].sourceId.source_label_text = "mutated";
definition.nodes[0].coordinates[0] = -99.0;
definition.sections[0].sectionPoints[0][0] = -99.0;
definition.steps[0].loads[0].magnitude = 99.0;
definition.warnings[0].code = "mutated";
const fesa::Domain& domain = result.value();
const fesa::Domain& domain = result.Value();
const fesa::Node* const firstNodeAddress = domain.nodes().data();
static_assert(std::is_same_v<
decltype(std::declval<const fesa::Domain&>().nodes()),
@@ -95,10 +95,10 @@ TEST(DomainModel, ImmutableOwnershipPreservesStableOrder) {
EXPECT_EQ(domain.sourcePath(), std::filesystem::path{"models/owned.inp"});
EXPECT_EQ(domain.sourceContentIdentity(), "fnv1a64:fedcba9876543210");
ASSERT_EQ(domain.nodes().size(), 2U);
EXPECT_EQ(domain.nodes()[0].sourceId.sourceLabel, 20);
EXPECT_EQ(domain.nodes()[0].sourceId.sourceLabelText, "0020");
EXPECT_EQ(domain.nodes()[0].sourceId.source_label, 20);
EXPECT_EQ(domain.nodes()[0].sourceId.source_label_text, "0020");
EXPECT_DOUBLE_EQ(domain.nodes()[0].coordinates[0], 2.0);
EXPECT_EQ(domain.nodes()[1].sourceId.sourceLabel, 10);
EXPECT_EQ(domain.nodes()[1].sourceId.source_label, 10);
EXPECT_EQ(domain.nodes().data(), firstNodeAddress);
ASSERT_EQ(domain.elements().size(), 1U);
@@ -162,23 +162,23 @@ TEST(DomainModel, MultipleIdentityInstancesDoNotMerge) {
{"models/two-instances.inp", 60U}}};
auto result = fesa::Domain::create(std::move(definition));
ASSERT_TRUE(result.hasValue());
const fesa::Domain& domain = result.value();
ASSERT_TRUE(result.HasValue());
const fesa::Domain& domain = result.Value();
ASSERT_EQ(domain.nodes().size(), 4U);
EXPECT_EQ(domain.nodes()[0].sourceId.sourceLabel, 1);
EXPECT_EQ(domain.nodes()[2].sourceId.sourceLabel, 1);
EXPECT_EQ(domain.nodes()[0].sourceId.sourceLabelText, "1");
EXPECT_EQ(domain.nodes()[2].sourceId.sourceLabelText, "1");
EXPECT_EQ(domain.nodes()[0].sourceId.source_label, 1);
EXPECT_EQ(domain.nodes()[2].sourceId.source_label, 1);
EXPECT_EQ(domain.nodes()[0].sourceId.source_label_text, "1");
EXPECT_EQ(domain.nodes()[2].sourceId.source_label_text, "1");
EXPECT_NE(
domain.nodes()[0].sourceId.instanceName,
domain.nodes()[2].sourceId.instanceName);
domain.nodes()[0].sourceId.instance_name,
domain.nodes()[2].sourceId.instance_name);
ASSERT_EQ(domain.elements().size(), 2U);
EXPECT_EQ(domain.elements()[0].sourceId.sourceLabel, 1);
EXPECT_EQ(domain.elements()[1].sourceId.sourceLabel, 1);
EXPECT_EQ(domain.elements()[0].sourceId.instanceName, "Instance-A");
EXPECT_EQ(domain.elements()[1].sourceId.instanceName, "Instance-B");
EXPECT_EQ(domain.elements()[0].sourceId.source_label, 1);
EXPECT_EQ(domain.elements()[1].sourceId.source_label, 1);
EXPECT_EQ(domain.elements()[0].sourceId.instance_name, "Instance-A");
EXPECT_EQ(domain.elements()[1].sourceId.instance_name, "Instance-B");
EXPECT_EQ(domain.elements()[0].nodeIndices[0], 0U);
EXPECT_EQ(domain.elements()[1].nodeIndices[0], 2U);
}
@@ -212,13 +212,13 @@ TEST(DomainModel, ShellOwnershipPreservesResolvedAssignmentsAndOptionalFrames) {
{0U, {0.0, 1.0, 0.0}, {1.0, 0.0, 0.0}, {0.0, 0.0, -1.0}}};
auto result = fesa::Domain::create(definition);
ASSERT_TRUE(result.hasValue());
ASSERT_TRUE(result.HasValue());
definition.shellSections[0].thickness = -1.0;
definition.shellElements[0].sourceId.sourceLabelText = "mutated";
definition.shellElements[0].sourceId.source_label_text = "mutated";
definition.shellNodeInitialFrames[0].director[2] = -1.0;
const fesa::Domain& domain = result.value();
const fesa::Domain& domain = result.Value();
static_assert(std::is_same_v<
decltype(std::declval<const fesa::Domain&>().shellElements()),
const std::vector<fesa::Mitc4ShellDefinition>&>);
@@ -230,9 +230,9 @@ TEST(DomainModel, ShellOwnershipPreservesResolvedAssignmentsAndOptionalFrames) {
const std::vector<fesa::ShellNodeInitialFrame>&>);
ASSERT_EQ(domain.shellElements().size(), 2U);
EXPECT_EQ(domain.shellElements()[0].sourceId.sourceLabel, 20);
EXPECT_EQ(domain.shellElements()[0].sourceId.sourceLabelText, "0020");
EXPECT_EQ(domain.shellElements()[1].sourceId.sourceLabel, 10);
EXPECT_EQ(domain.shellElements()[0].sourceId.source_label, 20);
EXPECT_EQ(domain.shellElements()[0].sourceId.source_label_text, "0020");
EXPECT_EQ(domain.shellElements()[1].sourceId.source_label, 10);
EXPECT_EQ(domain.shellElements()[0].sourceType, fesa::ShellSourceElementType::s4r);
EXPECT_EQ(domain.shellElements()[1].sourceType, fesa::ShellSourceElementType::s4);
EXPECT_EQ(domain.shellElements()[0].nodeIndices[3], 7U);
@@ -258,6 +258,6 @@ TEST(DomainModel, ShellOwnershipPreservesResolvedAssignmentsAndOptionalFrames) {
(std::array<double, 3>{0.0, 1.0, 0.0}));
auto noFramesResult = fesa::Domain::create(fesa::ModelDefinition{});
ASSERT_TRUE(noFramesResult.hasValue());
EXPECT_TRUE(noFramesResult.value().shellNodeInitialFrames().empty());
ASSERT_TRUE(noFramesResult.HasValue());
EXPECT_TRUE(noFramesResult.Value().shellNodeInitialFrames().empty());
}
tests/unit/model/model_types_test.cpp
+17 -17
View File
@@ -39,22 +39,22 @@ TEST(DomainModel, SourceAndInternalIdentityRemainDistinct) {
EXPECT_EQ(
std::make_tuple(
firstIdentity.instanceName,
firstIdentity.sourceLabel,
firstIdentity.sourceLabelText),
firstIdentity.instance_name,
firstIdentity.source_label,
firstIdentity.source_label_text),
std::make_tuple(
equalIdentity.instanceName,
equalIdentity.sourceLabel,
equalIdentity.sourceLabelText));
equalIdentity.instance_name,
equalIdentity.source_label,
equalIdentity.source_label_text));
EXPECT_LT(
std::make_tuple(
firstIdentity.instanceName,
firstIdentity.sourceLabel,
firstIdentity.sourceLabelText),
firstIdentity.instance_name,
firstIdentity.source_label,
firstIdentity.source_label_text),
std::make_tuple(
laterIdentity.instanceName,
laterIdentity.sourceLabel,
laterIdentity.sourceLabelText));
laterIdentity.instance_name,
laterIdentity.source_label,
laterIdentity.source_label_text));
const fesa::Node node{firstIdentity, {1.0, 2.0, 3.0}, nodeLocation};
const fesa::LinearElasticMaterial material{
@@ -116,7 +116,7 @@ TEST(DomainModel, SourceAndInternalIdentityRemainDistinct) {
definition.instances = {instance};
definition.steps = {step};
definition.warnings = {{
fesa::Severity::warning,
fesa::Severity::kWarning,
"ignored-output-request",
{"models/beam.inp", 75U},
"*OUTPUT",
@@ -124,7 +124,7 @@ TEST(DomainModel, SourceAndInternalIdentityRemainDistinct) {
"Output request does not alter mandatory FESA results."}};
ASSERT_EQ(definition.nodes.size(), 1U);
EXPECT_EQ(definition.nodes[0].sourceId.sourceLabelText, "0007");
EXPECT_EQ(definition.nodes[0].sourceId.source_label_text, "0007");
EXPECT_EQ(definition.nodes[0].location.line, 11U);
ASSERT_EQ(definition.instances.size(), 1U);
EXPECT_EQ(definition.instances[0].partName, "BeamPart");
@@ -167,9 +167,9 @@ TEST(DomainModel, Mitc4ShellRecordsPreserveSourceAndInternalIdentity) {
fesa::EntityIndex{7},
{"models/shell.inp", 21U}};
EXPECT_EQ(s4Element.sourceId.instanceName, "Shell-Instance");
EXPECT_EQ(s4Element.sourceId.sourceLabel, 41);
EXPECT_EQ(s4Element.sourceId.sourceLabelText, "0041");
EXPECT_EQ(s4Element.sourceId.instance_name, "Shell-Instance");
EXPECT_EQ(s4Element.sourceId.source_label, 41);
EXPECT_EQ(s4Element.sourceId.source_label_text, "0041");
EXPECT_EQ(s4Element.sourceType, fesa::ShellSourceElementType::s4);
EXPECT_EQ(s4rElement.sourceType, fesa::ShellSourceElementType::s4r);
EXPECT_NE(s4Element.sourceType, s4rElement.sourceType);
tests/unit/model/shell_geometry_test.cpp
+19 -19
View File
@@ -89,10 +89,10 @@ const fesa::ShellNodeInitialFrame& frameFor(
void expectFailureCode(
const fesa::Result<fesa::ShellGeometry>& result,
const std::string& code) {
ASSERT_FALSE(result.hasValue());
EXPECT_EQ(result.status().failureCategory(), fesa::FailureCategory::model);
ASSERT_EQ(result.status().diagnostics().size(), 1U);
EXPECT_EQ(result.status().diagnostics()[0].code, code);
ASSERT_FALSE(result.HasValue());
EXPECT_EQ(result.GetStatus().Category(), fesa::FailureCategory::kModel);
ASSERT_EQ(result.GetStatus().Diagnostics().size(), 1U);
EXPECT_EQ(result.GetStatus().Diagnostics()[0].code, code);
}
} // namespace
@@ -107,12 +107,12 @@ TEST(Mitc4Geometry, BuildsDeterministicFramesForPlanarRotatedAndWarpedElements)
auto planar = fesa::preprocessShellGeometry(
planarNodes, {element(10U, {0U, 1U, 2U, 3U})}, sections());
ASSERT_TRUE(planar.hasValue());
ASSERT_EQ(planar.value().elementData.size(), 1U);
expectVectorNear(planar.value().elementData[0].normalCandidate, {0.0, 0.0, 1.0});
EXPECT_NEAR(planar.value().elementData[0].surfaceAreaWeight, 1.0, 1.0e-12);
ASSERT_EQ(planar.value().nodalFrames.size(), 4U);
for (const auto& frame : planar.value().nodalFrames) {
ASSERT_TRUE(planar.HasValue());
ASSERT_EQ(planar.Value().elementData.size(), 1U);
expectVectorNear(planar.Value().elementData[0].normalCandidate, {0.0, 0.0, 1.0});
EXPECT_NEAR(planar.Value().elementData[0].surfaceAreaWeight, 1.0, 1.0e-12);
ASSERT_EQ(planar.Value().nodalFrames.size(), 4U);
for (const auto& frame : planar.Value().nodalFrames) {
expectVectorNear(frame.director, {0.0, 0.0, 1.0});
expectVectorNear(frame.tangentA, {1.0, 0.0, 0.0});
expectVectorNear(frame.tangentB, {0.0, 1.0, 0.0});
@@ -127,8 +127,8 @@ TEST(Mitc4Geometry, BuildsDeterministicFramesForPlanarRotatedAndWarpedElements)
auto rotated = fesa::preprocessShellGeometry(
rotatedNodes, {element(11U, {0U, 1U, 2U, 3U})}, sections());
ASSERT_TRUE(rotated.hasValue());
const auto& rotatedFrame = frameFor(rotated.value(), 0U);
ASSERT_TRUE(rotated.HasValue());
const auto& rotatedFrame = frameFor(rotated.Value(), 0U);
expectVectorNear(rotatedFrame.director, {1.0, 0.0, 0.0});
expectVectorNear(rotatedFrame.tangentA, {0.0, 1.0, 0.0});
expectVectorNear(rotatedFrame.tangentB, {0.0, 0.0, 1.0});
@@ -142,9 +142,9 @@ TEST(Mitc4Geometry, BuildsDeterministicFramesForPlanarRotatedAndWarpedElements)
auto warped = fesa::preprocessShellGeometry(
warpedNodes, {element(12U, {0U, 1U, 2U, 3U})}, sections());
ASSERT_TRUE(warped.hasValue());
EXPECT_GT(warped.value().elementData[0].surfaceAreaWeight, 2.0);
for (const auto& frame : warped.value().nodalFrames) {
ASSERT_TRUE(warped.HasValue());
EXPECT_GT(warped.Value().elementData[0].surfaceAreaWeight, 2.0);
for (const auto& frame : warped.Value().nodalFrames) {
expectRightHandedFrame(frame);
}
}
@@ -166,13 +166,13 @@ TEST(Mitc4Geometry, AreaWeightsSharedDirectorsInStableSourceIdentityOrder) {
auto second = fesa::preprocessShellGeometry(
nodes, {flat, tilted}, sections());
ASSERT_TRUE(first.hasValue());
ASSERT_TRUE(second.hasValue());
ASSERT_TRUE(first.HasValue());
ASSERT_TRUE(second.HasValue());
const Vector3 expectedSharedDirector{
-1.0 / std::sqrt(5.0), 0.0, 2.0 / std::sqrt(5.0)};
for (const auto sharedNode : {1U, 2U}) {
const auto& firstFrame = frameFor(first.value(), sharedNode);
const auto& secondFrame = frameFor(second.value(), sharedNode);
const auto& firstFrame = frameFor(first.Value(), sharedNode);
const auto& secondFrame = frameFor(second.Value(), sharedNode);
expectVectorNear(firstFrame.director, expectedSharedDirector);
expectVectorNear(firstFrame.director, secondFrame.director, 0.0);
expectVectorNear(firstFrame.tangentA, {0.0, 1.0, 0.0});