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

revert

Browse Source
This commit is contained in:
김경종
2026-06-10 10:03:11 +09:00
parent 87529c811a
commit 0912ee6f3b
174 changed files with 414 additions and 8544 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/analysis/analysis_base_test.cpp
-78
View File
@@ -1,78 +0,0 @@
#include "fesa/analysis/Analysis.hpp"
#include "fesa/core/AnalysisState.hpp"
#include "fesa/core/Domain.hpp"
#include <memory>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
class RecordingAnalysis final : public fesa::analysis::Analysis {
public:
const char* name() const noexcept override {
return "recording";
}
bool received_domain = false;
bool ran = false;
protected:
void doRun(const fesa::core::Domain& domain, fesa::core::AnalysisState& state) override {
received_domain = domain.nodeCount() == 1;
state.setCurrentTime(2.0);
ran = true;
}
};
int derived_analysis_runs_through_base_api() {
fesa::core::Domain domain;
domain.addNode(fesa::core::Node{1, 0.0, 0.0, 0.0});
fesa::core::AnalysisState state;
RecordingAnalysis analysis;
fesa::analysis::Analysis& base = analysis;
base.run(domain, state);
if (const int result = require(analysis.ran); result != 0) {
return result;
}
if (const int result = require(analysis.received_domain); result != 0) {
return result;
}
if (const int result = require(domain.nodeCount() == 1); result != 0) {
return result;
}
return require(state.currentTime() == 2.0);
}
int analysis_exposes_name_through_base_api() {
RecordingAnalysis analysis;
const fesa::analysis::Analysis& base = analysis;
return require(base.name()[0] == 'r');
}
int analysis_can_be_deleted_through_base_pointer() {
std::unique_ptr<fesa::analysis::Analysis> analysis = std::make_unique<RecordingAnalysis>();
return require(analysis->name()[0] == 'r');
}
} // namespace
int run_analysis_base_tests() {
if (const int result = derived_analysis_runs_through_base_api(); result != 0) {
return result;
}
if (const int result = analysis_exposes_name_through_base_api(); result != 0) {
return result;
}
if (const int result = analysis_can_be_deleted_through_base_pointer(); result != 0) {
return result;
}
return 0;
}
tests/analysis/analysis_test_main.cpp
-12
View File
@@ -1,12 +0,0 @@
int run_analysis_base_tests();
int run_analysis_state_tests();
int main() {
if (const int result = run_analysis_state_tests(); result != 0) {
return result;
}
if (const int result = run_analysis_base_tests(); result != 0) {
return result;
}
return 0;
}
tests/boundary/boundary_base_test.cpp
-31
View File
@@ -1,31 +0,0 @@
#include "fesa/boundary/BoundaryCondition.hpp"
#include "fesa/boundary/SinglePointConstraint.hpp"
#include <memory>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_boundary_base_tests() {
std::unique_ptr<fesa::boundary::BoundaryCondition> owned =
std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::UR3, 0.25);
const fesa::boundary::BoundaryCondition& boundary = *owned;
const auto& spc = static_cast<const fesa::boundary::SinglePointConstraint&>(boundary);
if (const int result = require(boundary.kind() == fesa::boundary::BoundaryConditionKind::SinglePointConstraint);
result != 0) {
return result;
}
if (const int result = require(spc.nodeId() == 1); result != 0) {
return result;
}
if (const int result = require(spc.dof() == fesa::core::Dof::UR3); result != 0) {
return result;
}
return require(spc.value() == 0.25);
}
tests/core/analysis_state_test.cpp
-203
View File
@@ -1,203 +0,0 @@
#include "fesa/core/AnalysisState.hpp"
#include <stdexcept>
#include <vector>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
template <typename Exception, typename Function>
int require_throws(Function&& function) {
try {
function();
} catch (const Exception&) {
return 0;
} catch (...) {
return 1;
}
return 1;
}
int default_state_has_no_dofs() {
const fesa::core::AnalysisState state;
if (const int result = require(state.dofCount() == 0); result != 0) {
return result;
}
if (const int result = require(state.displacement().empty()); result != 0) {
return result;
}
if (const int result = require(state.externalForce().empty()); result != 0) {
return result;
}
if (const int result = require(state.internalForce().empty()); result != 0) {
return result;
}
if (const int result = require(state.residual().empty()); result != 0) {
return result;
}
return require(state.reaction().empty());
}
int sized_state_initializes_zero_vectors() {
const fesa::core::AnalysisState state{3};
if (const int result = require(state.dofCount() == 3); result != 0) {
return result;
}
for (const auto* vector : {
&state.displacement(),
&state.externalForce(),
&state.internalForce(),
&state.residual(),
&state.reaction(),
}) {
if (const int result = require(vector->size() == state.dofCount()); result != 0) {
return result;
}
for (const double value : *vector) {
if (const int result = require(value == 0.0); result != 0) {
return result;
}
}
}
return 0;
}
int setters_replace_matching_size_vectors() {
fesa::core::AnalysisState state{2};
state.setDisplacement({1.0, 2.0});
state.setExternalForce({3.0, 4.0});
state.setInternalForce({5.0, 6.0});
state.setResidual({7.0, 8.0});
state.setReaction({9.0, 10.0});
if (const int result = require(state.displacement()[0] == 1.0 && state.displacement()[1] == 2.0); result != 0) {
return result;
}
if (const int result = require(state.externalForce()[0] == 3.0 && state.externalForce()[1] == 4.0); result != 0) {
return result;
}
if (const int result = require(state.internalForce()[0] == 5.0 && state.internalForce()[1] == 6.0); result != 0) {
return result;
}
if (const int result = require(state.residual()[0] == 7.0 && state.residual()[1] == 8.0); result != 0) {
return result;
}
return require(state.reaction()[0] == 9.0 && state.reaction()[1] == 10.0);
}
int mismatched_setter_preserves_existing_vector() {
fesa::core::AnalysisState state{2};
state.setDisplacement({1.0, 2.0});
if (const int result = require_throws<std::invalid_argument>([&state]() {
state.setDisplacement({3.0});
});
result != 0) {
return result;
}
return require(state.displacement()[0] == 1.0 && state.displacement()[1] == 2.0);
}
int resize_resets_all_vectors_to_zero() {
fesa::core::AnalysisState state{2};
state.setDisplacement({1.0, 2.0});
state.setExternalForce({3.0, 4.0});
state.resize(3);
if (const int result = require(state.dofCount() == 3); result != 0) {
return result;
}
for (const auto* vector : {
&state.displacement(),
&state.externalForce(),
&state.internalForce(),
&state.residual(),
&state.reaction(),
}) {
for (const double value : *vector) {
if (const int result = require(value == 0.0); result != 0) {
return result;
}
}
}
return 0;
}
int clear_forces_preserves_displacement() {
fesa::core::AnalysisState state{2};
state.setDisplacement({1.0, 2.0});
state.setExternalForce({3.0, 4.0});
state.setInternalForce({5.0, 6.0});
state.setResidual({7.0, 8.0});
state.setReaction({9.0, 10.0});
state.clearForces();
if (const int result = require(state.displacement()[0] == 1.0 && state.displacement()[1] == 2.0); result != 0) {
return result;
}
for (const auto* vector : {
&state.externalForce(),
&state.internalForce(),
&state.residual(),
&state.reaction(),
}) {
for (const double value : *vector) {
if (const int result = require(value == 0.0); result != 0) {
return result;
}
}
}
return 0;
}
int counters_can_be_updated() {
fesa::core::AnalysisState state;
state.setCurrentTime(1.25);
state.setIncrementIndex(3);
state.setIterationIndex(5);
if (const int result = require(state.currentTime() == 1.25); result != 0) {
return result;
}
if (const int result = require(state.incrementIndex() == 3); result != 0) {
return result;
}
return require(state.iterationIndex() == 5);
}
} // namespace
int run_analysis_state_tests() {
if (const int result = default_state_has_no_dofs(); result != 0) {
return result;
}
if (const int result = sized_state_initializes_zero_vectors(); result != 0) {
return result;
}
if (const int result = setters_replace_matching_size_vectors(); result != 0) {
return result;
}
if (const int result = mismatched_setter_preserves_existing_vector(); result != 0) {
return result;
}
if (const int result = resize_resets_all_vectors_to_zero(); result != 0) {
return result;
}
if (const int result = clear_forces_preserves_displacement(); result != 0) {
return result;
}
if (const int result = counters_can_be_updated(); result != 0) {
return result;
}
return 0;
}
tests/core/boundary_condition_test.cpp
-25
View File
@@ -1,25 +0,0 @@
#include "fesa/core/BoundaryCondition.hpp"
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_boundary_condition_tests() {
const fesa::core::BoundaryCondition condition{1, fesa::core::Dof::UR3, 0.25};
if (const int result = require(condition.nodeId() == 1); result != 0) {
return result;
}
if (const int result = require(condition.dof() == fesa::core::Dof::UR3); result != 0) {
return result;
}
if (const int result = require(condition.value() == 0.25); result != 0) {
return result;
}
return 0;
}
tests/core/domain_bootstrap_test.cpp
-44
View File
@@ -1,44 +0,0 @@
int run_boundary_condition_tests();
int run_domain_model_object_tests();
int run_domain_storage_tests();
int run_element_definition_tests();
int run_load_definition_tests();
int run_material_definition_tests();
int run_model_types_tests();
int run_node_tests();
int run_property_definition_tests();
int run_step_definition_tests();
int main() {
if (const int result = run_model_types_tests(); result != 0) {
return result;
}
if (const int result = run_node_tests(); result != 0) {
return result;
}
if (const int result = run_element_definition_tests(); result != 0) {
return result;
}
if (const int result = run_material_definition_tests(); result != 0) {
return result;
}
if (const int result = run_property_definition_tests(); result != 0) {
return result;
}
if (const int result = run_boundary_condition_tests(); result != 0) {
return result;
}
if (const int result = run_domain_model_object_tests(); result != 0) {
return result;
}
if (const int result = run_load_definition_tests(); result != 0) {
return result;
}
if (const int result = run_step_definition_tests(); result != 0) {
return result;
}
if (const int result = run_domain_storage_tests(); result != 0) {
return result;
}
return 0;
}
tests/core/domain_model_object_test.cpp
-170
View File
@@ -1,170 +0,0 @@
#include "fesa/boundary/SinglePointConstraint.hpp"
#include "fesa/core/Domain.hpp"
#include "fesa/element/Mitc4Element.hpp"
#include "fesa/load/NodalLoad.hpp"
#include "fesa/material/LinearElasticMaterial.hpp"
#include "fesa/property/ShellProperty.hpp"
#include <memory>
#include <stdexcept>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
template <typename Exception, typename Function>
int require_throws(Function&& function) {
try {
function();
} catch (const Exception&) {
return 0;
} catch (...) {
return 1;
}
return 1;
}
fesa::core::Domain populated_domain() {
fesa::core::Domain domain;
domain.addNode(fesa::core::Node{1, 0.0, 0.0, 0.0});
domain.addNode(fesa::core::Node{2, 1.0, 0.0, 0.0});
domain.addNode(fesa::core::Node{3, 1.0, 1.0, 0.0});
domain.addNode(fesa::core::Node{4, 0.0, 1.0, 0.0});
domain.addMaterial(std::make_unique<fesa::material::LinearElasticMaterial>(700, 210.0, 0.3));
domain.addShellProperty(std::make_unique<fesa::property::ShellProperty>(500, 700, 0.01));
return domain;
}
int domain_owns_element_and_material_objects() {
fesa::core::Domain domain = populated_domain();
domain.addElement(std::make_unique<fesa::element::Mitc4Element>(
100,
std::array<fesa::core::NodeId, 4>{1, 2, 3, 4},
500));
const fesa::element::Element* element = domain.findElement(100);
if (const int result = require(element != nullptr); result != 0) {
return result;
}
if (const int result = require(element->type() == fesa::core::ElementType::Mitc4); result != 0) {
return result;
}
if (const int result = require(domain.element(100).propertyId() == 500); result != 0) {
return result;
}
const fesa::material::Material* material = domain.findMaterial(700);
if (const int result = require(material != nullptr); result != 0) {
return result;
}
return require(domain.material(700).id() == 700);
}
int duplicate_element_and_material_object_ids_throw() {
fesa::core::Domain domain = populated_domain();
domain.addElement(std::make_unique<fesa::element::Mitc4Element>(
100,
std::array<fesa::core::NodeId, 4>{1, 2, 3, 4},
500));
if (const int result = require_throws<std::invalid_argument>([&domain]() {
domain.addElement(std::make_unique<fesa::element::Mitc4Element>(
100,
std::array<fesa::core::NodeId, 4>{1, 2, 3, 4},
500));
});
result != 0) {
return result;
}
return require_throws<std::invalid_argument>([&domain]() {
domain.addMaterial(std::make_unique<fesa::material::LinearElasticMaterial>(700, 100.0, 0.25));
});
}
int missing_model_object_direct_lookup_throws() {
const fesa::core::Domain domain;
if (const int result = require(domain.findElement(404) == nullptr); result != 0) {
return result;
}
if (const int result = require(domain.findMaterial(404) == nullptr); result != 0) {
return result;
}
if (const int result = require_throws<std::out_of_range>([&domain]() {
(void)domain.element(404);
});
result != 0) {
return result;
}
return require_throws<std::out_of_range>([&domain]() {
(void)domain.material(404);
});
}
int domain_owns_load_and_boundary_objects_by_index() {
fesa::core::Domain domain = populated_domain();
const std::size_t load_index = domain.addLoad(
std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -100.0));
const std::size_t boundary_index = domain.addBoundaryCondition(
std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::U1, 0.0));
if (const int result = require(load_index == 0); result != 0) {
return result;
}
if (const int result = require(boundary_index == 0); result != 0) {
return result;
}
if (const int result = require(domain.findLoad(load_index) != nullptr); result != 0) {
return result;
}
if (const int result = require(domain.findBoundaryCondition(boundary_index) != nullptr); result != 0) {
return result;
}
if (const int result = require(domain.load(load_index).kind() == fesa::load::LoadKind::Nodal); result != 0) {
return result;
}
return require(
domain.boundaryCondition(boundary_index).kind() ==
fesa::boundary::BoundaryConditionKind::SinglePointConstraint);
}
int duplicate_load_and_boundary_keys_throw() {
fesa::core::Domain domain = populated_domain();
domain.addLoad(std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -100.0));
domain.addBoundaryCondition(std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::U1, 0.0));
if (const int result = require_throws<std::invalid_argument>([&domain]() {
domain.addLoad(std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -200.0));
});
result != 0) {
return result;
}
return require_throws<std::invalid_argument>([&domain]() {
domain.addBoundaryCondition(std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::U1, 1.0));
});
}
} // namespace
int run_domain_model_object_tests() {
if (const int result = domain_owns_element_and_material_objects(); result != 0) {
return result;
}
if (const int result = duplicate_element_and_material_object_ids_throw(); result != 0) {
return result;
}
if (const int result = missing_model_object_direct_lookup_throws(); result != 0) {
return result;
}
if (const int result = domain_owns_load_and_boundary_objects_by_index(); result != 0) {
return result;
}
if (const int result = duplicate_load_and_boundary_keys_throw(); result != 0) {
return result;
}
return 0;
}
tests/core/domain_storage_test.cpp
-702
View File
@@ -1,702 +0,0 @@
#include "fesa/boundary/SinglePointConstraint.hpp"
#include "fesa/core/Domain.hpp"
#include "fesa/core/Node.hpp"
#include "fesa/core/StepDefinition.hpp"
#include "fesa/element/Mitc4Element.hpp"
#include "fesa/load/NodalLoad.hpp"
#include "fesa/material/LinearElasticMaterial.hpp"
#include "fesa/property/ShellProperty.hpp"
#include <array>
#include <memory>
#include <stdexcept>
#include <type_traits>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
template <typename Exception, typename Function>
int require_throws(Function&& function) {
try {
function();
} catch (const Exception&) {
return 0;
} catch (...) {
return 1;
}
return 1;
}
void add_four_nodes(fesa::core::Domain& domain) {
domain.addNode(fesa::core::Node{1, 0.0, 0.0, 0.0});
domain.addNode(fesa::core::Node{2, 1.0, 0.0, 0.0});
domain.addNode(fesa::core::Node{3, 1.0, 1.0, 0.0});
domain.addNode(fesa::core::Node{4, 0.0, 1.0, 0.0});
}
void add_material_and_property(fesa::core::Domain& domain) {
domain.addMaterial(std::make_unique<fesa::material::LinearElasticMaterial>(700, 210.0, 0.3));
domain.addShellProperty(std::make_unique<fesa::property::ShellProperty>(500, 700, 0.01));
}
void add_element(fesa::core::Domain& domain) {
domain.addElement(std::make_unique<fesa::element::Mitc4Element>(
100,
std::array<fesa::core::NodeId, 4>{1, 2, 3, 4},
500));
}
int add_and_retrieve_node_by_id() {
fesa::core::Domain domain;
domain.addNode(fesa::core::Node{10, 1.0, 2.0, 3.0});
if (const int result = require(domain.nodeCount() == 1); result != 0) {
return result;
}
const fesa::core::Node* found = domain.findNode(10);
if (const int result = require(found != nullptr); result != 0) {
return result;
}
if (const int result = require(found->id() == 10); result != 0) {
return result;
}
if (const int result = require(found->x() == 1.0); result != 0) {
return result;
}
if (const int result = require(found->y() == 2.0); result != 0) {
return result;
}
if (const int result = require(found->z() == 3.0); result != 0) {
return result;
}
const fesa::core::Node& direct = domain.node(10);
return require(direct.id() == 10);
}
int missing_node_lookup_contracts() {
const fesa::core::Domain domain;
if (const int result = require(domain.findNode(99) == nullptr); result != 0) {
return result;
}
return require_throws<std::out_of_range>([&domain]() {
(void)domain.node(99);
});
}
int duplicate_node_id_throws() {
fesa::core::Domain domain;
domain.addNode(fesa::core::Node{10, 0.0, 0.0, 0.0});
return require_throws<std::invalid_argument>([&domain]() {
domain.addNode(fesa::core::Node{10, 1.0, 0.0, 0.0});
});
}
int add_and_retrieve_element_by_id() {
fesa::core::Domain domain;
add_four_nodes(domain);
add_material_and_property(domain);
add_element(domain);
if (const int result = require(domain.elementCount() == 1); result != 0) {
return result;
}
const fesa::element::Element* found = domain.findElement(100);
if (const int result = require(found != nullptr); result != 0) {
return result;
}
if (const int result = require(found->id() == 100); result != 0) {
return result;
}
if (const int result = require(found->type() == fesa::core::ElementType::Mitc4); result != 0) {
return result;
}
if (const int result = require(found->propertyId() == 500); result != 0) {
return result;
}
if (const int result = require(found->connectivity()[0] == 1); result != 0) {
return result;
}
if (const int result = require(found->connectivity()[1] == 2); result != 0) {
return result;
}
if (const int result = require(found->connectivity()[2] == 3); result != 0) {
return result;
}
if (const int result = require(found->connectivity()[3] == 4); result != 0) {
return result;
}
const fesa::element::Element& direct = domain.element(100);
return require(direct.id() == 100);
}
int duplicate_element_id_throws() {
fesa::core::Domain domain;
add_four_nodes(domain);
add_material_and_property(domain);
add_element(domain);
return require_throws<std::invalid_argument>([&domain]() {
domain.addElement(std::make_unique<fesa::element::Mitc4Element>(
100,
std::array<fesa::core::NodeId, 4>{1, 2, 3, 4},
500));
});
}
int element_referencing_missing_node_throws() {
fesa::core::Domain domain;
domain.addNode(fesa::core::Node{1, 0.0, 0.0, 0.0});
domain.addNode(fesa::core::Node{2, 1.0, 0.0, 0.0});
domain.addNode(fesa::core::Node{3, 1.0, 1.0, 0.0});
add_material_and_property(domain);
return require_throws<std::invalid_argument>([&domain]() {
domain.addElement(std::make_unique<fesa::element::Mitc4Element>(
100,
std::array<fesa::core::NodeId, 4>{1, 2, 3, 4},
500));
});
}
int element_referencing_missing_property_throws() {
fesa::core::Domain domain;
add_four_nodes(domain);
domain.addMaterial(std::make_unique<fesa::material::LinearElasticMaterial>(700, 210.0, 0.3));
return require_throws<std::invalid_argument>([&domain]() {
domain.addElement(std::make_unique<fesa::element::Mitc4Element>(
100,
std::array<fesa::core::NodeId, 4>{1, 2, 3, 4},
500));
});
}
int missing_element_lookup_contracts() {
const fesa::core::Domain domain;
if (const int result = require(domain.findElement(404) == nullptr); result != 0) {
return result;
}
return require_throws<std::out_of_range>([&domain]() {
(void)domain.element(404);
});
}
int add_and_retrieve_material_and_property() {
fesa::core::Domain domain;
add_material_and_property(domain);
if (const int result = require(domain.materialCount() == 1); result != 0) {
return result;
}
if (const int result = require(domain.shellPropertyCount() == 1); result != 0) {
return result;
}
const fesa::material::Material* material = domain.findMaterial(700);
if (const int result = require(material != nullptr); result != 0) {
return result;
}
if (const int result = require(material->id() == 700); result != 0) {
return result;
}
const fesa::property::Property* property = domain.findProperty(500);
if (const int result = require(property != nullptr); result != 0) {
return result;
}
if (const int result = require(property->kind() == fesa::property::PropertyKind::Shell); result != 0) {
return result;
}
const fesa::property::ShellProperty* shell_property = domain.findShellProperty(500);
if (const int result = require(shell_property != nullptr); result != 0) {
return result;
}
if (const int result = require(shell_property->materialId() == 700); result != 0) {
return result;
}
if (const int result = require(shell_property->thickness() == 0.01); result != 0) {
return result;
}
if (const int result = require(domain.material(700).id() == 700); result != 0) {
return result;
}
return require(domain.property(500).id() == 500);
}
int duplicate_material_and_property_ids_throw() {
fesa::core::Domain domain;
add_material_and_property(domain);
if (const int result = require_throws<std::invalid_argument>([&domain]() {
domain.addMaterial(std::make_unique<fesa::material::LinearElasticMaterial>(700, 100.0, 0.25));
});
result != 0) {
return result;
}
return require_throws<std::invalid_argument>([&domain]() {
domain.addShellProperty(std::make_unique<fesa::property::ShellProperty>(500, 700, 0.02));
});
}
int shell_property_referencing_missing_material_throws() {
fesa::core::Domain domain;
return require_throws<std::invalid_argument>([&domain]() {
domain.addShellProperty(std::make_unique<fesa::property::ShellProperty>(500, 700, 0.01));
});
}
int null_property_rejected() {
fesa::core::Domain domain;
return require_throws<std::invalid_argument>([&domain]() {
domain.addProperty(nullptr);
});
}
int add_and_retrieve_sets() {
fesa::core::Domain domain;
add_four_nodes(domain);
add_material_and_property(domain);
add_element(domain);
domain.addNodeSet("left-edge", {1, 4});
domain.addElementSet("shells", {100});
const auto* node_set = domain.findNodeSet("left-edge");
if (const int result = require(node_set != nullptr); result != 0) {
return result;
}
if (const int result = require(node_set->size() == 2); result != 0) {
return result;
}
if (const int result = require((*node_set)[0] == 1); result != 0) {
return result;
}
if (const int result = require((*node_set)[1] == 4); result != 0) {
return result;
}
const auto* element_set = domain.findElementSet("shells");
if (const int result = require(element_set != nullptr); result != 0) {
return result;
}
if (const int result = require(element_set->size() == 1); result != 0) {
return result;
}
if (const int result = require((*element_set)[0] == 100); result != 0) {
return result;
}
if (const int result = require(domain.nodeSetCount() == 1); result != 0) {
return result;
}
return require(domain.elementSetCount() == 1);
}
int duplicate_set_names_throw() {
fesa::core::Domain domain;
add_four_nodes(domain);
add_material_and_property(domain);
add_element(domain);
domain.addNodeSet("left-edge", {1, 4});
domain.addElementSet("shells", {100});
if (const int result = require_throws<std::invalid_argument>([&domain]() {
domain.addNodeSet("left-edge", {1});
});
result != 0) {
return result;
}
return require_throws<std::invalid_argument>([&domain]() {
domain.addElementSet("shells", {100});
});
}
int sets_referencing_missing_ids_throw() {
fesa::core::Domain domain;
add_four_nodes(domain);
add_material_and_property(domain);
add_element(domain);
if (const int result = require_throws<std::invalid_argument>([&domain]() {
domain.addNodeSet("bad-nodes", {1, 99});
});
result != 0) {
return result;
}
return require_throws<std::invalid_argument>([&domain]() {
domain.addElementSet("bad-elements", {100, 404});
});
}
int add_and_retrieve_boundary_condition() {
fesa::core::Domain domain;
domain.addNode(fesa::core::Node{1, 0.0, 0.0, 0.0});
const std::size_t index = domain.addBoundaryCondition(
std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::U1, 0.0));
if (const int result = require(index == 0); result != 0) {
return result;
}
if (const int result = require(domain.boundaryConditionCount() == 1); result != 0) {
return result;
}
const fesa::boundary::BoundaryCondition& condition = domain.boundaryCondition(index);
if (const int result = require(condition.kind() == fesa::boundary::BoundaryConditionKind::SinglePointConstraint);
result != 0) {
return result;
}
const auto& spc = static_cast<const fesa::boundary::SinglePointConstraint&>(condition);
if (const int result = require(spc.nodeId() == 1); result != 0) {
return result;
}
if (const int result = require(spc.dof() == fesa::core::Dof::U1); result != 0) {
return result;
}
return require(spc.value() == 0.0);
}
int add_and_retrieve_nodal_load() {
fesa::core::Domain domain;
domain.addNode(fesa::core::Node{1, 0.0, 0.0, 0.0});
const std::size_t index = domain.addLoad(
std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -100.0));
if (const int result = require(index == 0); result != 0) {
return result;
}
if (const int result = require(domain.loadCount() == 1); result != 0) {
return result;
}
const fesa::load::Load& load = domain.load(index);
if (const int result = require(load.kind() == fesa::load::LoadKind::Nodal); result != 0) {
return result;
}
const auto& nodal_load = static_cast<const fesa::load::NodalLoad&>(load);
if (const int result = require(nodal_load.nodeId() == 1); result != 0) {
return result;
}
if (const int result = require(nodal_load.dof() == fesa::core::Dof::U3); result != 0) {
return result;
}
return require(nodal_load.value() == -100.0);
}
int missing_node_boundary_condition_and_load_throw() {
fesa::core::Domain domain;
if (const int result = require_throws<std::invalid_argument>([&domain]() {
(void)domain.addBoundaryCondition(
std::make_unique<fesa::boundary::SinglePointConstraint>(99, fesa::core::Dof::U1, 0.0));
});
result != 0) {
return result;
}
return require_throws<std::invalid_argument>([&domain]() {
(void)domain.addLoad(
std::make_unique<fesa::load::NodalLoad>(99, fesa::core::Dof::U3, -100.0));
});
}
int duplicate_load_and_boundary_keys_throw() {
fesa::core::Domain domain;
domain.addNode(fesa::core::Node{1, 0.0, 0.0, 0.0});
domain.addBoundaryCondition(
std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::U1, 0.0));
domain.addLoad(std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -100.0));
if (const int result = require_throws<std::invalid_argument>([&domain]() {
(void)domain.addBoundaryCondition(
std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::U1, 1.0));
});
result != 0) {
return result;
}
return require_throws<std::invalid_argument>([&domain]() {
(void)domain.addLoad(
std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -200.0));
});
}
int add_and_retrieve_linear_static_step() {
fesa::core::Domain domain;
domain.addNode(fesa::core::Node{1, 0.0, 0.0, 0.0});
const std::size_t bc = domain.addBoundaryCondition(
std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::U1, 0.0));
const std::size_t load = domain.addLoad(
std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -100.0));
domain.addStep(fesa::core::LinearStaticStepDefinition{1, "load-step", {bc}, {load}});
if (const int result = require(domain.stepCount() == 1); result != 0) {
return result;
}
const fesa::core::LinearStaticStepDefinition* found = domain.findStep(1);
if (const int result = require(found != nullptr); result != 0) {
return result;
}
if (const int result = require(found->id() == 1); result != 0) {
return result;
}
if (const int result = require(found->name() == "load-step"); result != 0) {
return result;
}
if (const int result = require(found->boundaryConditionIndices().size() == 1); result != 0) {
return result;
}
if (const int result = require(found->boundaryConditionIndices()[0] == bc); result != 0) {
return result;
}
if (const int result = require(found->loadIndices().size() == 1); result != 0) {
return result;
}
return require(found->loadIndices()[0] == load);
}
int duplicate_and_invalid_step_references_throw() {
fesa::core::Domain domain;
domain.addNode(fesa::core::Node{1, 0.0, 0.0, 0.0});
const std::size_t bc = domain.addBoundaryCondition(
std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::U1, 0.0));
const std::size_t load = domain.addLoad(
std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -100.0));
domain.addStep(fesa::core::LinearStaticStepDefinition{1, "load-step", {bc}, {load}});
if (const int result = require_throws<std::invalid_argument>([&domain, bc, load]() {
domain.addStep(fesa::core::LinearStaticStepDefinition{1, "duplicate", {bc}, {load}});
});
result != 0) {
return result;
}
if (const int result = require_throws<std::invalid_argument>([&domain, load]() {
domain.addStep(fesa::core::LinearStaticStepDefinition{2, "bad-bc", {99}, {load}});
});
result != 0) {
return result;
}
return require_throws<std::invalid_argument>([&domain, bc]() {
domain.addStep(fesa::core::LinearStaticStepDefinition{2, "bad-load", {bc}, {99}});
});
}
int const_domain_retrieval_returns_const_runtime_model_data() {
fesa::core::Domain domain;
add_four_nodes(domain);
add_material_and_property(domain);
add_element(domain);
domain.addNodeSet("left-edge", {1, 4});
domain.addElementSet("shells", {100});
const std::size_t bc = domain.addBoundaryCondition(
std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::U1, 0.0));
const std::size_t load = domain.addLoad(
std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -100.0));
domain.addStep(fesa::core::LinearStaticStepDefinition{1, "load-step", {bc}, {load}});
const fesa::core::Domain& const_domain = domain;
if (const int result = require((std::is_same<decltype(const_domain.node(1)), const fesa::core::Node&>::value));
result != 0) {
return result;
}
if (const int result = require((std::is_same<decltype(const_domain.element(100)), const fesa::element::Element&>::value));
result != 0) {
return result;
}
if (const int result = require((std::is_same<decltype(const_domain.material(700)), const fesa::material::Material&>::value));
result != 0) {
return result;
}
if (const int result = require((std::is_same<decltype(const_domain.property(500)), const fesa::property::Property&>::value));
result != 0) {
return result;
}
if (const int result = require((std::is_same<decltype(const_domain.shellProperty(500)), const fesa::property::ShellProperty&>::value));
result != 0) {
return result;
}
if (const int result = require((std::is_same<decltype(const_domain.nodeSet("left-edge")), const std::vector<fesa::core::NodeId>&>::value));
result != 0) {
return result;
}
if (const int result = require((std::is_same<decltype(const_domain.elementSet("shells")), const std::vector<fesa::core::ElementId>&>::value));
result != 0) {
return result;
}
if (const int result = require((std::is_same<decltype(const_domain.boundaryCondition(0)), const fesa::boundary::BoundaryCondition&>::value));
result != 0) {
return result;
}
if (const int result = require((std::is_same<decltype(const_domain.load(0)), const fesa::load::Load&>::value));
result != 0) {
return result;
}
return require((std::is_same<decltype(const_domain.step(1)), const fesa::core::LinearStaticStepDefinition&>::value));
}
int failed_inserts_do_not_mutate_counts() {
fesa::core::Domain domain;
add_four_nodes(domain);
add_material_and_property(domain);
add_element(domain);
domain.addNodeSet("left-edge", {1, 4});
domain.addElementSet("shells", {100});
const std::size_t bc = domain.addBoundaryCondition(
std::make_unique<fesa::boundary::SinglePointConstraint>(1, fesa::core::Dof::U1, 0.0));
const std::size_t load = domain.addLoad(
std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -100.0));
domain.addStep(fesa::core::LinearStaticStepDefinition{1, "load-step", {bc}, {load}});
if (const int result = require_throws<std::invalid_argument>([&domain]() {
domain.addElement(std::make_unique<fesa::element::Mitc4Element>(
101,
std::array<fesa::core::NodeId, 4>{1, 2, 3, 99},
500));
});
result != 0) {
return result;
}
if (const int result = require(domain.elementCount() == 1); result != 0) {
return result;
}
if (const int result = require_throws<std::invalid_argument>([&domain]() {
domain.addShellProperty(std::make_unique<fesa::property::ShellProperty>(501, 404, 0.01));
});
result != 0) {
return result;
}
if (const int result = require(domain.shellPropertyCount() == 1); result != 0) {
return result;
}
if (const int result = require_throws<std::invalid_argument>([&domain]() {
domain.addNodeSet("bad-nodes", {1, 99});
});
result != 0) {
return result;
}
if (const int result = require(domain.nodeSetCount() == 1); result != 0) {
return result;
}
if (const int result = require_throws<std::invalid_argument>([&domain]() {
(void)domain.addBoundaryCondition(
std::make_unique<fesa::boundary::SinglePointConstraint>(99, fesa::core::Dof::U1, 0.0));
});
result != 0) {
return result;
}
if (const int result = require(domain.boundaryConditionCount() == 1); result != 0) {
return result;
}
if (const int result = require_throws<std::invalid_argument>([&domain, bc]() {
domain.addStep(fesa::core::LinearStaticStepDefinition{2, "bad-load", {bc}, {99}});
});
result != 0) {
return result;
}
return require(domain.stepCount() == 1);
}
} // namespace
int run_domain_storage_tests() {
if (const int result = add_and_retrieve_node_by_id(); result != 0) {
return result;
}
if (const int result = missing_node_lookup_contracts(); result != 0) {
return result;
}
if (const int result = duplicate_node_id_throws(); result != 0) {
return result;
}
if (const int result = add_and_retrieve_element_by_id(); result != 0) {
return result;
}
if (const int result = duplicate_element_id_throws(); result != 0) {
return result;
}
if (const int result = element_referencing_missing_node_throws(); result != 0) {
return result;
}
if (const int result = element_referencing_missing_property_throws(); result != 0) {
return result;
}
if (const int result = missing_element_lookup_contracts(); result != 0) {
return result;
}
if (const int result = add_and_retrieve_material_and_property(); result != 0) {
return result;
}
if (const int result = duplicate_material_and_property_ids_throw(); result != 0) {
return result;
}
if (const int result = shell_property_referencing_missing_material_throws(); result != 0) {
return result;
}
if (const int result = null_property_rejected(); result != 0) {
return result;
}
if (const int result = add_and_retrieve_sets(); result != 0) {
return result;
}
if (const int result = duplicate_set_names_throw(); result != 0) {
return result;
}
if (const int result = sets_referencing_missing_ids_throw(); result != 0) {
return result;
}
if (const int result = add_and_retrieve_boundary_condition(); result != 0) {
return result;
}
if (const int result = add_and_retrieve_nodal_load(); result != 0) {
return result;
}
if (const int result = missing_node_boundary_condition_and_load_throw(); result != 0) {
return result;
}
if (const int result = duplicate_load_and_boundary_keys_throw(); result != 0) {
return result;
}
if (const int result = add_and_retrieve_linear_static_step(); result != 0) {
return result;
}
if (const int result = duplicate_and_invalid_step_references_throw(); result != 0) {
return result;
}
if (const int result = const_domain_retrieval_returns_const_runtime_model_data(); result != 0) {
return result;
}
if (const int result = failed_inserts_do_not_mutate_counts(); result != 0) {
return result;
}
return 0;
}
tests/core/element_definition_test.cpp
-41
View File
@@ -1,41 +0,0 @@
#include "fesa/core/ElementDefinition.hpp"
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_element_definition_tests() {
const fesa::core::ElementDefinition element{
100,
fesa::core::ElementType::Mitc4,
{1, 2, 3, 4},
500};
if (const int result = require(element.id() == 100); result != 0) {
return result;
}
if (const int result = require(element.type() == fesa::core::ElementType::Mitc4); result != 0) {
return result;
}
if (const int result = require(element.connectivity()[0] == 1); result != 0) {
return result;
}
if (const int result = require(element.connectivity()[1] == 2); result != 0) {
return result;
}
if (const int result = require(element.connectivity()[2] == 3); result != 0) {
return result;
}
if (const int result = require(element.connectivity()[3] == 4); result != 0) {
return result;
}
if (const int result = require(element.propertyId() == 500); result != 0) {
return result;
}
return 0;
}
tests/core/load_definition_test.cpp
-25
View File
@@ -1,25 +0,0 @@
#include "fesa/core/LoadDefinition.hpp"
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_load_definition_tests() {
const fesa::core::NodalLoadDefinition load{1, fesa::core::Dof::U3, -100.0};
if (const int result = require(load.nodeId() == 1); result != 0) {
return result;
}
if (const int result = require(load.dof() == fesa::core::Dof::U3); result != 0) {
return result;
}
if (const int result = require(load.value() == -100.0); result != 0) {
return result;
}
return 0;
}
tests/core/material_definition_test.cpp
-25
View File
@@ -1,25 +0,0 @@
#include "fesa/core/MaterialDefinition.hpp"
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_material_definition_tests() {
const fesa::core::LinearElasticMaterialDefinition material{700, 210.0, 0.3};
if (const int result = require(material.id() == 700); result != 0) {
return result;
}
if (const int result = require(material.youngModulus() == 210.0); result != 0) {
return result;
}
if (const int result = require(material.poissonRatio() == 0.3); result != 0) {
return result;
}
return 0;
}
tests/core/model_types_test.cpp
-49
View File
@@ -1,49 +0,0 @@
#include "fesa/core/ModelTypes.hpp"
#include <cstdint>
#include <type_traits>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_model_types_tests() {
using namespace fesa::core;
if (const int result = require(sizeof(Id) == 8); result != 0) {
return result;
}
if (const int result = require(std::is_same<Id, std::int64_t>::value); result != 0) {
return result;
}
if (const int result = require(kDofPerNode == 6); result != 0) {
return result;
}
if (const int result = require(ElementType::Mitc4 == ElementType::Mitc4); result != 0) {
return result;
}
if (const int result = require(static_cast<int>(Dof::U1) == 0); result != 0) {
return result;
}
if (const int result = require(static_cast<int>(Dof::U2) == 1); result != 0) {
return result;
}
if (const int result = require(static_cast<int>(Dof::U3) == 2); result != 0) {
return result;
}
if (const int result = require(static_cast<int>(Dof::UR1) == 3); result != 0) {
return result;
}
if (const int result = require(static_cast<int>(Dof::UR2) == 4); result != 0) {
return result;
}
if (const int result = require(static_cast<int>(Dof::UR3) == 5); result != 0) {
return result;
}
return 0;
}
tests/core/node_test.cpp
-47
View File
@@ -1,47 +0,0 @@
#include "fesa/core/Node.hpp"
#include <array>
#include <type_traits>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_node_tests() {
const fesa::core::Node node{42, 1.0, 2.0, 3.0};
if (const int result = require(fesa::core::Node::dofCount() == 6); result != 0) {
return result;
}
if (const int result = require(node.id() == 42); result != 0) {
return result;
}
if (const int result = require(node.x() == 1.0); result != 0) {
return result;
}
if (const int result = require(node.y() == 2.0); result != 0) {
return result;
}
if (const int result = require(node.z() == 3.0); result != 0) {
return result;
}
if (const int result = require(node.coordinates()[0] == 1.0); result != 0) {
return result;
}
if (const int result = require(node.coordinates()[1] == 2.0); result != 0) {
return result;
}
if (const int result = require(node.coordinates()[2] == 3.0); result != 0) {
return result;
}
if (const int result = require((std::is_same<decltype(node.coordinates()), const std::array<double, 3>&>::value));
result != 0) {
return result;
}
return 0;
}
tests/core/property_definition_test.cpp
-25
View File
@@ -1,25 +0,0 @@
#include "fesa/core/PropertyDefinition.hpp"
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_property_definition_tests() {
const fesa::core::ShellPropertyDefinition property{500, 700, 0.01};
if (const int result = require(property.id() == 500); result != 0) {
return result;
}
if (const int result = require(property.materialId() == 700); result != 0) {
return result;
}
if (const int result = require(property.thickness() == 0.01); result != 0) {
return result;
}
return 0;
}
tests/core/step_definition_test.cpp
-37
View File
@@ -1,37 +0,0 @@
#include "fesa/core/StepDefinition.hpp"
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_step_definition_tests() {
const fesa::core::LinearStaticStepDefinition step{1, "load-step", {0, 2}, {1}};
if (const int result = require(step.id() == 1); result != 0) {
return result;
}
if (const int result = require(step.name() == "load-step"); result != 0) {
return result;
}
if (const int result = require(step.boundaryConditionIndices().size() == 2); result != 0) {
return result;
}
if (const int result = require(step.boundaryConditionIndices()[0] == 0); result != 0) {
return result;
}
if (const int result = require(step.boundaryConditionIndices()[1] == 2); result != 0) {
return result;
}
if (const int result = require(step.loadIndices().size() == 1); result != 0) {
return result;
}
if (const int result = require(step.loadIndices()[0] == 1); result != 0) {
return result;
}
return 0;
}
tests/element/element_base_test.cpp
-51
View File
@@ -1,51 +0,0 @@
#include "fesa/element/Element.hpp"
#include <array>
#include <memory>
namespace {
using fesa::element::ElementId;
using fesa::element::ElementType;
using fesa::element::NodeId;
using fesa::element::PropertyId;
int require(bool condition) {
return condition ? 0 : 1;
}
class TestElement final : public fesa::element::Element {
public:
ElementId id() const noexcept override { return 100; }
ElementType type() const noexcept override { return ElementType::Mitc4; }
std::size_t nodeCount() const noexcept override { return connectivity_.size(); }
const std::array<NodeId, 4>& connectivity() const noexcept override { return connectivity_; }
PropertyId propertyId() const noexcept override { return 500; }
private:
std::array<NodeId, 4> connectivity_{1, 2, 3, 4};
};
} // namespace
int run_element_base_tests() {
std::unique_ptr<fesa::element::Element> owned = std::make_unique<TestElement>();
const fesa::element::Element& element = *owned;
if (const int result = require(element.id() == 100); result != 0) {
return result;
}
if (const int result = require(element.type() == fesa::core::ElementType::Mitc4); result != 0) {
return result;
}
if (const int result = require(element.nodeCount() == 4); result != 0) {
return result;
}
if (const int result = require(element.connectivity()[0] == 1); result != 0) {
return result;
}
if (const int result = require(element.connectivity()[3] == 4); result != 0) {
return result;
}
return require(element.propertyId() == 500);
}
tests/element/mitc4_element_model_test.cpp
-40
View File
@@ -1,40 +0,0 @@
#include "fesa/element/Mitc4Element.hpp"
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_mitc4_element_model_tests() {
const fesa::element::Mitc4Element mitc4{100, {1, 2, 3, 4}, 500};
const fesa::element::Element& element = mitc4;
if (const int result = require(element.id() == 100); result != 0) {
return result;
}
if (const int result = require(element.type() == fesa::core::ElementType::Mitc4); result != 0) {
return result;
}
if (const int result = require(element.nodeCount() == 4); result != 0) {
return result;
}
if (const int result = require(mitc4.dofCount() == 24); result != 0) {
return result;
}
if (const int result = require(element.connectivity()[0] == 1); result != 0) {
return result;
}
if (const int result = require(element.connectivity()[1] == 2); result != 0) {
return result;
}
if (const int result = require(element.connectivity()[2] == 3); result != 0) {
return result;
}
if (const int result = require(element.connectivity()[3] == 4); result != 0) {
return result;
}
return require(element.propertyId() == 500);
}
tests/io/hdf5_result_writer_test.cpp
-44
View File
@@ -1,44 +0,0 @@
#include "fesa/io/Hdf5ResultWriter.hpp"
#include <stdexcept>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
template <typename Exception, typename Function>
int require_throws(Function&& function) {
try {
function();
} catch (const Exception&) {
return 0;
} catch (...) {
return 1;
}
return 1;
}
int construct_writer_preserves_output_path() {
const fesa::io::Hdf5ResultWriter writer{"results.h5"};
return require(writer.filePath() == "results.h5");
}
int empty_output_path_throws() {
return require_throws<std::invalid_argument>([]() {
(void)fesa::io::Hdf5ResultWriter{""};
});
}
} // namespace
int main() {
if (const int result = construct_writer_preserves_output_path(); result != 0) {
return result;
}
if (const int result = empty_output_path_throws(); result != 0) {
return result;
}
return 0;
}
tests/load/load_base_test.cpp
-30
View File
@@ -1,30 +0,0 @@
#include "fesa/load/Load.hpp"
#include "fesa/load/NodalLoad.hpp"
#include <memory>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_load_base_tests() {
std::unique_ptr<fesa::load::Load> owned =
std::make_unique<fesa::load::NodalLoad>(1, fesa::core::Dof::U3, -100.0);
const fesa::load::Load& load = *owned;
const auto& nodal = static_cast<const fesa::load::NodalLoad&>(load);
if (const int result = require(load.kind() == fesa::load::LoadKind::Nodal); result != 0) {
return result;
}
if (const int result = require(nodal.nodeId() == 1); result != 0) {
return result;
}
if (const int result = require(nodal.dof() == fesa::core::Dof::U3); result != 0) {
return result;
}
return require(nodal.value() == -100.0);
}
tests/material/material_base_test.cpp
-27
View File
@@ -1,27 +0,0 @@
#include "fesa/material/LinearElasticMaterial.hpp"
#include "fesa/material/Material.hpp"
#include <memory>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
} // namespace
int run_material_base_tests() {
std::unique_ptr<fesa::material::Material> owned =
std::make_unique<fesa::material::LinearElasticMaterial>(700, 210.0, 0.3);
const fesa::material::Material& material = *owned;
const auto& elastic = static_cast<const fesa::material::LinearElasticMaterial&>(material);
if (const int result = require(material.id() == 700); result != 0) {
return result;
}
if (const int result = require(elastic.youngModulus() == 210.0); result != 0) {
return result;
}
return require(elastic.poissonRatio() == 0.3);
}
tests/model_object_main.cpp
-32
View File
@@ -1,32 +0,0 @@
int run_boundary_base_tests();
int run_element_base_tests();
int run_load_base_tests();
int run_material_base_tests();
int run_mitc4_element_model_tests();
int run_property_base_tests();
int run_shell_property_tests();
int main() {
if (const int result = run_boundary_base_tests(); result != 0) {
return result;
}
if (const int result = run_element_base_tests(); result != 0) {
return result;
}
if (const int result = run_mitc4_element_model_tests(); result != 0) {
return result;
}
if (const int result = run_material_base_tests(); result != 0) {
return result;
}
if (const int result = run_property_base_tests(); result != 0) {
return result;
}
if (const int result = run_shell_property_tests(); result != 0) {
return result;
}
if (const int result = run_load_base_tests(); result != 0) {
return result;
}
return 0;
}
tests/property/property_base_test.cpp
-37
View File
@@ -1,37 +0,0 @@
#include "fesa/property/Property.hpp"
#include <memory>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
class TestProperty final : public fesa::property::Property {
public:
explicit TestProperty(fesa::core::PropertyId id) : id_(id) {}
fesa::core::PropertyId id() const noexcept override {
return id_;
}
fesa::property::PropertyKind kind() const noexcept override {
return fesa::property::PropertyKind::Shell;
}
private:
fesa::core::PropertyId id_;
};
} // namespace
int run_property_base_tests() {
std::unique_ptr<fesa::property::Property> owned = std::make_unique<TestProperty>(500);
const fesa::property::Property& property = *owned;
if (const int result = require(property.id() == 500); result != 0) {
return result;
}
return require(property.kind() == fesa::property::PropertyKind::Shell);
}
tests/property/shell_property_test.cpp
-54
View File
@@ -1,54 +0,0 @@
#include "fesa/property/ShellProperty.hpp"
#include "fesa/property/Property.hpp"
#include <stdexcept>
namespace {
int require(bool condition) {
return condition ? 0 : 1;
}
template <typename Exception, typename Function>
int require_throws(Function&& function) {
try {
function();
} catch (const Exception&) {
return 0;
} catch (...) {
return 1;
}
return 1;
}
} // namespace
int run_shell_property_tests() {
const fesa::property::ShellProperty property{500, 700, 0.01};
const fesa::property::Property& base = property;
if (const int result = require(property.id() == 500); result != 0) {
return result;
}
if (const int result = require(base.id() == 500); result != 0) {
return result;
}
if (const int result = require(base.kind() == fesa::property::PropertyKind::Shell); result != 0) {
return result;
}
if (const int result = require(property.materialId() == 700); result != 0) {
return result;
}
if (const int result = require(property.thickness() == 0.01); result != 0) {
return result;
}
if (const int result = require_throws<std::invalid_argument>([]() {
(void)fesa::property::ShellProperty{501, 700, 0.0};
});
result != 0) {
return result;
}
return require_throws<std::invalid_argument>([]() {
(void)fesa::property::ShellProperty{502, 700, -0.01};
});
}