Rodin::Tests::Unit namespace

Namespace Rodin::Tests.

Directory Rodin/tests

Unitary tests

Classes

class Assembly_OpenMP_Problem

Single-variable Problem: Default assembler (OpenMP when available) produces same operator as Sequential for all 2D geometries.

class FlowTest

Unit tests for Flow class basic functionality.

class FMMTest

Basic unit tests for Fast Marching Method (FMM)

class LagrangianTest

Unit tests for Lagrangian class basic functionality.

Functions

TEST(IndexArrayEquality, BothEmptyArrays)

Verifies both empty arrays for index array equality by checking true predicates.

TEST(IndexArrayEquality, SingleElementEqual)

Verifies single element equal for index array equality by checking true predicates.

TEST(IndexArrayEquality, SingleElementDifferent)

Verifies single element different for index array equality by checking false predicates.

TEST(IndexArrayEquality, Size2Equal)

Verifies size 2 equal for index array equality by checking true predicates.

TEST(IndexArrayEquality, Size2Different)

Order matters here.

TEST(IndexArrayEquality, Size3Equal)

Verifies size 3 equal for index array equality by checking true predicates.

TEST(IndexArrayEquality, Size3Different)

Even though a permutation might be considered equal in symmetric sense,.

TEST(IndexArrayEquality, DifferentSizes)

Verifies different sizes for index array equality by checking false predicates.

void checkOpenMPSelfIdentificationMatchesZeroValueConstraint()

Helper used by the tests to Check Open MP Self Identification Matches Zero Value Constraint.

TEST_P(Assembly_OpenMP_LinearForm, ConstantLoad_MatchesSequential_P1)

Constant load f = 1: OpenMP result equals Sequential result.

TEST_P(Assembly_OpenMP_LinearForm, ConstantLoad_MatchesSequential_P0)

P0 constant load: OpenMP result equals Sequential result.

INSTANTIATE_TEST_SUITE_P(AllGeometries, Assembly_OpenMP_LinearForm, ::testing::Values(Polytope::Type::Segment, Polytope::Type::Triangle, Polytope::Type::Quadrilateral, Polytope::Type::Tetrahedron, Polytope::Type::Hexahedron, Polytope::Type::Pyramid, Polytope::Type::Wedge))

Instantiates Assembly Open MP Linear Form over the All Geometries parameter coverage.

TEST_P(Assembly_OpenMP_BilinearForm, P1StiffnessMatrix_MatchesSequential)

P1 stiffness matrix: OpenMP result equals Sequential result.

TEST_P(Assembly_OpenMP_BilinearForm, P1MassMatrix_MatchesSequential)

P1 mass matrix: OpenMP result equals Sequential result.

TEST_P(Assembly_OpenMP_BilinearForm, P0MassMatrix_MatchesSequential)

P0 mass matrix: OpenMP result equals Sequential result.

TEST_P(Assembly_OpenMP_BilinearForm, NonSquare_P0test_P1trial_MatchesSequential)

Non-square mixed BF (P0 test × P1 trial): OpenMP equals Sequential.

TEST_P(Assembly_OpenMP_BilinearForm, SingleThread_EqualsSequential_P1Stiffness)

OpenMP with explicit thread count 1 gives same result as Sequential.

INSTANTIATE_TEST_SUITE_P(AllGeometries, Assembly_OpenMP_BilinearForm, ::testing::Values(Polytope::Type::Segment, Polytope::Type::Triangle, Polytope::Type::Quadrilateral, Polytope::Type::Tetrahedron, Polytope::Type::Hexahedron, Polytope::Type::Pyramid, Polytope::Type::Wedge))

Instantiates Assembly Open MP Bilinear Form over the All Geometries parameter coverage.

TEST_P(Assembly_OpenMP_Problem, SingleVar_P1_DimensionsCorrect)

Verifies single var P1 dimensions correct for assembly open MP problem by checking exact expected values, form assembly.

TEST_P(Assembly_OpenMP_Problem, MultiVar_P0P1_DimensionsCorrect)

Verifies multi var P0 P1 dimensions correct for assembly open MP problem by checking exact expected values, form assembly.

TEST(Assembly_OpenMP_Problem, AffineIdentificationDefectMatchesSequential)

Verifies affine identification defect matches sequential for assembly open MP problem by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Assembly_OpenMP_Problem, IdentificationVectorMasterMatchesSequential)

Verifies identification vector master matches sequential for assembly open MP problem by checking tolerance-based numerical results, exact expected values, true predicates.

TEST(Assembly_OpenMP_Problem, SelfIdentificationMatchesZeroValueConstraint)

Verifies self identification matches zero value constraint for assembly open MP problem by checking form assembly.

INSTANTIATE_TEST_SUITE_P(AllGeometries, Assembly_OpenMP_Problem, ::testing::Values(Polytope::Type::Segment, Polytope::Type::Triangle, Polytope::Type::Quadrilateral, Polytope::Type::Tetrahedron, Polytope::Type::Hexahedron, Polytope::Type::Pyramid, Polytope::Type::Wedge))

Instantiates Assembly Open MP Problem over the All Geometries parameter coverage.

TEST(Assembly_Sequential_LinearForm, VectorSize_P1_4x4)

Assembled vector has the expected size (one entry per DOF).

TEST(Assembly_Sequential_LinearForm, VectorSize_P1_Quad_4x4)

Assembled vector has the expected size for Quadrilateral meshes.

TEST(Assembly_Sequential_LinearForm, ConstantRHS_EntriesPositive_P1)

All entries of ∫ 1· v dΩ are positive for a positive basis.

TEST(Assembly_Sequential_LinearForm, ConstantRHS_SumEqualsArea_P0)

∫ 1· v dΩ with P0 sums to area (each element has exactly one DOF and the mass is |K|).

TEST(Assembly_Sequential_LinearForm, LinearScaling_P1)

Scaling: ∫ 2· v dΩ = 2 · ∫ 1· v dΩ.

TEST(Assembly_Sequential_BilinearForm_Sparse, MatrixDimensions_P1_4x4)

Stiffness matrix has correct dimensions.

TEST(Assembly_Sequential_BilinearForm_Sparse, P0MassMatrix_IsDiagonal)

P0 mass matrix is diagonal (each element has one DOF).

TEST(Assembly_Sequential_BilinearForm_Sparse, P1MassMatrix_IsSymmetric)

P1 mass matrix is symmetric.

TEST(Assembly_Sequential_BilinearForm_Sparse, P1StiffnessMatrix_IsSymmetric)

P1 stiffness matrix is symmetric.

TEST(Assembly_Sequential_BilinearForm_Sparse, P1MassMatrix_SumEqualsArea)

P1 mass matrix row-sum equals domain area (∑_j M_ij summed over all i,j equals ∫_Ω 1 dΩ = area(Ω)). For UniformGrid({4,4}) the domain is [0,3]x[0,3] so area = 9.

TEST(Assembly_Sequential_BilinearForm_Sparse, NonSquare_P0test_P1trial_Dimensions)

Non-square BF: P1 trial, P0 test. Dimensions must match (testSize × trialSize).

TEST(Assembly_Sequential_Problem_SingleVar, Dimensions_P1_4x4)

Single-variable Problem: assembled system has correct dimensions.

TEST(Assembly_Sequential_Problem_SingleVar, DirichletBC_RowIsIdentity_P1)

DirichletBC is enforced: fixed DOF row is an identity row and RHS entry equals the prescribed value.

TEST(Assembly_Sequential_Problem_SingleVar, PreassembledBF_MatchesIntegral_P1)

Preassembled BF added to a single-variable Problem produces the same matrix as assembling the integral directly.

TEST(Assembly_Sequential_Problem_SingleVar, PreassembledLF_MatchesIntegral_P1)

Preassembled LF added to a single-variable Problem produces the same RHS vector as assembling the integral directly.

TEST(Assembly_Sequential_Problem_MultiVar, Dimensions_P0P1_4x4)

Multi-variable Problem: global system has combined DOF count.

TEST(Assembly_Sequential_Problem_MultiVar, PreassembledBF_BlockOffset_P0P1)

Multi-variable preassembled BF: block [p,q] placed at correct offset in the global matrix.

TEST(Assembly_Sequential_Problem_MultiVar, PreassembledLF_BlockOffset_P0P1)

Multi-variable preassembled LF: block [q] placed at correct offset in the global RHS vector.

TEST(Assembly_Problem_Identification, PreassembledFormsProjectRowsColumnsAndVector)

Verifies preassembled forms project rows columns and vector for assembly problem identification by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Assembly_Problem_Identification, AffineIdentificationWritesDefectRows)

Verifies affine identification writes defect rows for assembly problem identification by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Assembly_Problem_Identification, SequentialVectorMasterProjectsMultipleFiniteSpaces)

Verifies sequential vector master projects multiple finite spaces for assembly problem identification by checking tolerance-based numerical results, exact expected values, true predicates.

TEST(Assembly_Problem_Identification, SelfIdentificationMatchesZeroValueConstraint)

Verifies self identification matches zero value constraint for assembly problem identification by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Assembly_Problem_Identification, OverlappingValueAndIdentificationThrows)

Verifies overlapping value and identification throws for assembly problem identification by checking exception behavior, form assembly.

static auto makeAllGeomMesh(Polytope::Type geom, size_t n = 4) -> Mesh<Context::Local>

Creates a mesh with minimal connectivity for cell integration.

TEST_P(Assembly_Sequential_AllGeometries, LF_VectorSize_P1)

P1 LinearForm vector size equals the FES DOF count for every supported geometry type.

TEST_P(Assembly_Sequential_AllGeometries, LF_VectorSize_P0)

P0 LinearForm vector size equals the FES DOF count (= cell count) for every supported geometry type.

TEST_P(Assembly_Sequential_AllGeometries, BF_StiffnessMatrix_Dimensions_P1)

P1 stiffness matrix has correct square dimensions for every supported geometry type.

TEST_P(Assembly_Sequential_AllGeometries, BF_MassMatrix_IsSymmetric_P1)

P1 mass matrix is symmetric for every supported geometry type.

TEST_P(Assembly_Sequential_AllGeometries, BF_StiffnessMatrix_IsSymmetric_P1)

P1 stiffness matrix is symmetric for every supported geometry type.

TEST_P(Assembly_Sequential_AllGeometries, BF_P0MassMatrix_IsDiagonal)

P0 mass matrix is diagonal for every supported geometry type (each cell has exactly one P0 DOF, so there is no inter-cell coupling).

TEST_P(Assembly_Sequential_AllGeometries, LF_LoadVector_P0_EntriesPositive)

P0 load vector: all entries are positive (element measure > 0) for every supported geometry type.

INSTANTIATE_TEST_SUITE_P(AllGeometries, Assembly_Sequential_AllGeometries, ::testing::Values(Polytope::Type::Segment, Polytope::Type::Triangle, Polytope::Type::Quadrilateral, Polytope::Type::Tetrahedron, Polytope::Type::Hexahedron, Polytope::Type::Pyramid, Polytope::Type::Wedge))

Instantiates Assembly Sequential All Geometries over the All Geometries parameter coverage.

TEST(Rodin_Cast, TemplateDeclaration)

Test that the Cast template class is declared and can be used.

TEST(Rodin_Cast, IntToDoubleCast)

Verifies int to double cast for cast by checking tolerance-based numerical results.

TEST(Rodin_Cast, DoubleToIntCast)

Verifies double to int cast for cast by checking exact expected values.

TEST(Rodin_Cast, PointerCastSuccess)

Verifies pointer cast success for cast by checking exact expected values.

TEST(Rodin_Cast, PointerCastFailure)

Verifies pointer cast failure for cast by checking exact expected values.

TEST(Rodin_Cast, ZeroValues)

Verifies zero values for cast by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Cast, NegativeValues)

Verifies negative values for cast by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Cast, LargeValues)

Verifies large values for cast by checking tolerance-based numerical results.

TEST(Rodin_Cast, NullPointer)

Verifies null pointer for cast by checking exact expected values.

TEST(Rodin_Cast, FunctorBehavior)

Test that Cast objects can be used as functors.

TEST(Rodin_Cast, ConstCorrectness)

Verifies const correctness for cast by checking tolerance-based numerical results.

TEST(Rodin_Cast, TypeSafety)

These should compile correctly.

TEST(Rodin_Cast, DocumentationExample)

Test the example from the documentation comment.

TEST(Rodin_MPI_Context, ConstGetters)

Verifies const getters for MPI context by checking exact expected values, MPI behavior.

TEST(Rodin_Copyable, BasicCopy)

Verifies basic copy for copyable by checking exact expected values, copy semantics.

TEST(Rodin_Copyable, CopyIndependence)

Verifies copy independence for copyable by checking exact expected values, copy semantics.

TEST(Rodin_Copyable, PolymorphicCopy)

Verifies polymorphic copy for copyable by checking exact expected values, copy semantics.

TEST(Rodin_Copyable, StringValueCopy)

Verifies string value copy for copyable by checking exact expected values, copy semantics.

TEST(Rodin_Copyable, EmptyStringCopy)

Verifies empty string copy for copyable by checking exact expected values, copy semantics.

TEST(Rodin_Copyable, NoExceptSpecification)

Verify that copy() is declared as noexcept.

TEST(Rodin_FlatSet, IndexSetEquality_BothEmpty)

Verifies index set equality both empty for flat set by checking true predicates.

TEST(Rodin_FlatSet, IndexSetEquality_DifferentSizes)

Verifies index set equality different sizes for flat set by checking false predicates.

TEST(Rodin_FlatSet, IndexSetEquality_SameSizeDifferentElements)

Verifies index set equality same size different elements for flat set by checking false predicates.

TEST(Rodin_FlatSet, IndexSetEquality_SameElements)

Verifies index set equality same elements for flat set by checking true predicates.

TEST(Rodin_FlatSet, IndexSetEquality_SingleElement)

Verifies index set equality single element for flat set by checking true predicates, false predicates.

TEST(Rodin_FlatSet, IndexSetEquality_OrderMatters)

Note: FlatSet maintains sorted order, so this tests the underlying comparison.

TEST(Rodin_FlatSet, IndexSetEquality_LargeSet)

Verifies index set equality large set for flat set by checking true predicates, false predicates.

TEST(Rodin_FlatSet, IndexSetHash_EmptySet)

Verifies index set hash empty set for flat set by checking exact expected values.

TEST(Rodin_FlatSet, IndexSetHash_SingleElement)

Verifies index set hash single element for flat set by checking exact expected values.

TEST(Rodin_FlatSet, IndexSetHash_MultipleElements)

Verifies index set hash multiple elements for flat set by checking exact expected values.

TEST(Rodin_FlatSet, IndexSetHash_OrderIndependent)

Verifies index set hash order independent for flat set by checking exact expected values.

TEST(Rodin_FlatSet, IndexSetHash_Consistency)

Verifies index set hash consistency for flat set by checking exact expected values.

TEST(Rodin_FlatSet, IndexSetHash_DifferentSets)

Verifies index set hash different sets for flat set.

TEST(Rodin_FlatSet, IndexSetHash_LargeSet)

Verifies index set hash large set for flat set by checking exact expected values.

TEST(Rodin_FlatSet, EqualityAndHashConsistency)

Verifies equality and hash consistency for flat set by checking exact expected values, true predicates, false predicates.

TEST(Rodin_FlatSet, FunctorCallOperator)

Test that functors can be used with parentheses operator.

TEST(FormLanguage_List, DefaultConstruction) private

Verifies default construction for form language list by checking exact expected values, true predicates.

TEST(FormLanguage_List, CopyConstruction) private

Verifies copy construction for form language list by checking exact expected values, copy semantics.

TEST(FormLanguage_List, MoveConstruction) private

Verifies move construction for form language list by checking exact expected values, move semantics.

TEST(FormLanguage_List, CopyAssignment) private

Verifies copy assignment for form language list by checking exact expected values, copy semantics.

TEST(FormLanguage_List, MoveAssignment) private

Verifies move assignment for form language list by checking exact expected values, move semantics.

TEST(FormLanguage_List, AddSingleElement) private

Verifies add single element for form language list by checking exact expected values, false predicates.

TEST(FormLanguage_List, AddMultipleElements) private

Verifies add multiple elements for form language list by checking exact expected values.

TEST(FormLanguage_List, AddAnotherList) private

Verifies add another list for form language list by checking exact expected values.

TEST(FormLanguage_List, AtAccessConst) private

Verifies at access const for form language list by checking exact expected values.

TEST(FormLanguage_List, Clear) private

Verifies clear for form language list by checking exact expected values, true predicates.

TEST(FormLanguage_List, IteratorBeginEnd) private

Verifies iterator begin end for form language list by checking exact expected values.

TEST(FormLanguage_List, IteratorPostIncrement) private

Verifies iterator post increment for form language list by checking exact expected values.

TEST(FormLanguage_List, IteratorRangeBasedFor) private

Verifies iterator range based for for form language list by checking exact expected values.

TEST(FormLanguage_List, ConstIteratorBeginEnd) private

Verifies const iterator begin end for form language list by checking exact expected values.

TEST(FormLanguage_List, ConstIteratorCBeginCEnd) private

Verifies const iterator C begin C end for form language list by checking exact expected values.

TEST(FormLanguage_List, ConstIteratorRangeBasedFor) private

Verifies const iterator range based for for form language list by checking exact expected values.

TEST(FormLanguage_List, CopyMethod) private

Verifies copy method for form language list by checking exact expected values, copy semantics.

TEST(FormLanguage_List, EmptyListIterators) private

Verifies empty list iterators for form language list by checking exact expected values.

TEST(FormLanguage_List, EmptyListCopy) private

Verifies empty list copy for form language list by checking exact expected values, true predicates, copy semantics.

TEST(FormLanguage_List, ClearEmptyList) private

Verifies clear empty list for form language list by checking exact expected values, true predicates.

TEST(Geometry_AttributeIndex, SetAndGetCellAttribute)

Verifies set and get cell attribute for geometry attribute index by checking exact expected values, true predicates.

TEST(Geometry_AttributeIndex, SetAndGetMultipleCells)

Verifies set and get multiple cells for geometry attribute index by checking exact expected values, true predicates.

TEST(Geometry_AttributeIndex, GetMultipleAttributes)

Verifies get multiple attributes for geometry attribute index by checking exact expected values, true predicates.

TEST(Geometry_AttributeIndex, SetBoundaryAttributes)

Verifies set boundary attributes for geometry attribute index by checking exact expected values, true predicates.

TEST(Geometry_AttributeIndex, VertexAttributes)

Verifies vertex attributes for geometry attribute index by checking exact expected values, true predicates.

TEST(Geometry_AttributeIndex, ConcurrentReadersAndWriter)

Verifies coherent attribute snapshots during concurrent reads and writes.

TEST(Geometry_ConnectivityExt, Chain_2D_Edges_Then_Vertices)

Verifies chain 2 D edges then vertices for geometry connectivity ext by checking exact expected values, mesh connectivity computation.

TEST(Geometry_ConnectivityExt, Chain_3D_Faces_Then_Edges)

Verifies chain 3 D faces then edges for geometry connectivity ext by checking exact expected values, mesh connectivity computation.

TEST(Geometry_ConnectivityExt, Chain_2D_Compute_Then_Adjacency)

Verifies chain 2 D compute then adjacency for geometry connectivity ext by checking mesh connectivity computation.

TEST(Geometry_ConnectivityExt, Local_EdgeVertices)

Verifies local edge vertices for geometry connectivity ext by checking exact expected values, mesh connectivity computation.

TEST(Geometry_ConnectivityExt, Local_TriangleVertices)

Verifies local triangle vertices for geometry connectivity ext by checking exact expected values.

TEST(Geometry_ConnectivityExt, Local_QuadVertices)

Verifies local quad vertices for geometry connectivity ext by checking exact expected values.

TEST(Geometry_ConnectivityExt, Local_TetVertices)

Verifies local tet vertices for geometry connectivity ext by checking exact expected values.

TEST(Geometry_ConnectivityExt, Clear_EdgeIncidence)

Verifies clear edge incidence for geometry connectivity ext by checking mesh connectivity computation.

TEST(Geometry_ConnectivityExt, PolytopeCount_AllDimensions)

Verifies polytope count all dimensions for geometry connectivity ext by checking mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, SanityTest_2D_3Nodes_Triangles)

Verifies sanity test 2 D 3 nodes triangles for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, SanityTest2D_4Nodes_Triangles)

Verifies sanity test 2 D 4 nodes triangles for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, SanityTest2D_5Nodes_Triangles)

Verifies sanity test 2 D 5 nodes triangles for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, SanityTest2D_5Nodes_Mixed)

Verifies sanity test 2 D 5 nodes mixed for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, SanityTest2D_9Nodes_Mixed)

Verifies sanity test 2 D 9 nodes mixed for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, Quadrilateral_2D)

Verifies quadrilateral 2 D for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, Tetrahedron_3D)

Verifies tetrahedron 3 D for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, Pyramid_3D)

Verifies pyramid 3 D for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EmptyMesh)

Verifies empty mesh for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, MultipleComputeCalls)

Verifies multiple compute calls for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_ZeroNodes)

Verifies edge case zero nodes for geometry connectivity by checking exact expected values.

TEST(Rodin_Geometry_Connectivity, EdgeCase_SingleNode_NoPolytopes)

Verifies edge case single node no polytopes for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_MultipleNodes_NoPolytopes)

Verifies edge case multiple nodes no polytopes for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_1D_SingleSegment)

Verifies edge case 1 D single segment for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_1D_MultipleSegments)

Verifies edge case 1 D multiple segments for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_3D_SingleTetrahedron)

Verifies edge case 3 D single tetrahedron for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_CopyConstruction)

Verifies edge case copy construction for geometry connectivity by checking exact expected values, mesh connectivity computation, copy semantics.

TEST(Rodin_Geometry_Connectivity, EdgeCase_MoveConstruction)

Verifies edge case move construction for geometry connectivity by checking exact expected values, mesh connectivity computation, move semantics.

TEST(Rodin_Geometry_Connectivity, EdgeCase_CopyAssignment)

Verifies edge case copy assignment for geometry connectivity by checking exact expected values, mesh connectivity computation, copy semantics.

TEST(Rodin_Geometry_Connectivity, EdgeCase_MoveAssignment)

Verifies edge case move assignment for geometry connectivity by checking exact expected values, mesh connectivity computation, move semantics.

TEST(Rodin_Geometry_Connectivity, EdgeCase_DegenerateTriangle_DuplicateVertex)

Verifies edge case degenerate triangle duplicate vertex for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_ComputeOrder_Dependency)

Verifies edge case compute order dependency for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_GetCountByGeometry_Triangle)

Verifies edge case get count by geometry triangle for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_AllQuadrilaterals)

Verifies edge case all quadrilaterals for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_3D_TwoTets_SharedFace)

Verifies edge case 3 D two tets shared face for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_ComputeTranspose)

Verifies edge case compute transpose for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_Clear_Specific_Connectivity)

Verifies edge case clear specific connectivity for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_Reserve_Performance)

Verifies edge case reserve performance for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_GetGeometry_AllDimensions)

Verifies edge case get geometry all dimensions for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_GetPolytope_VertexIndices)

Verifies edge case get polytope vertex indices for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, EdgeCase_InterfaceBoundary_SingleCell)

Verifies edge case interface boundary single cell for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, Mode_Discover_2D_AddsEdges)

Verifies mode discover 2 D adds edges for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, Mode_Restrict_2D_OnlyUsesExisting)

Verifies mode restrict 2 D only uses existing for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, Mode_Discover_3D_AddsFaces)

Verifies mode discover 3 D adds faces for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, Mode_Restrict_3D_OnlyUsesExisting)

Verifies mode restrict 3 D only uses existing for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, Mode_Discover_Mixed_2D)

Verifies mode discover mixed 2 D for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, Mode_Restrict_WithPartialEdges)

Verifies mode restrict with partial edges for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, UniformGrid_2D_Triangles_Small)

Verifies uniform grid 2 D triangles small for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, UniformGrid_2D_Triangles_Medium)

Verifies uniform grid 2 D triangles medium for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, UniformGrid_2D_Quadrilaterals)

Verifies uniform grid 2 D quadrilaterals for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, UniformGrid_3D_Tetrahedra)

Verifies uniform grid 3 D tetrahedra for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, UniformGrid_2D_BoundaryAndInterface)

Verifies uniform grid 2 D boundary and interface for geometry connectivity by checking mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, ComplexMixed_2D_TrianglesAndQuads)

Verifies complex mixed 2 D triangles and quads for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, ComplexMixed_3D_TetsAndWedges)

Verifies complex mixed 3 D tets and wedges for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, NonTrivial_DisconnectedComponents)

Verifies non trivial disconnected components for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, NonTrivial_ComplexSharing)

Verifies non trivial complex sharing for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, NonTrivial_LargeMesh_Consistency)

Verifies non trivial large mesh consistency for geometry connectivity by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, NonTrivial_AllDimensionConnectivity)

Verifies non trivial all dimension connectivity for geometry connectivity by checking true predicates, mesh connectivity computation.

TEST(Rodin_Geometry_Connectivity, Mode_Comparison_SameResults)

Test that Discover and Restrict give same results when edges pre-exist.

TEST(Geometry_IdentityTransformation, Construction)

Verifies construction for geometry identity transformation by checking exact expected values.

TEST(Geometry_IdentityTransformation, Construction3D)

Verifies construction 3 D for geometry identity transformation by checking exact expected values.

TEST(Geometry_IdentityTransformation, Transform2D)

Verifies transform 2 D for geometry identity transformation by checking tolerance-based numerical results.

TEST(Geometry_IdentityTransformation, Transform3D)

Verifies transform 3 D for geometry identity transformation by checking tolerance-based numerical results.

TEST(Geometry_IdentityTransformation, Jacobian2D)

Verifies jacobian 2 D for geometry identity transformation by checking tolerance-based numerical results.

TEST(Geometry_IdentityTransformation, Jacobian3D)

Verifies jacobian 3 D for geometry identity transformation by checking tolerance-based numerical results.

TEST(Geometry_IdentityTransformation, Copy)

Verifies copy for geometry identity transformation by checking tolerance-based numerical results, exact expected values, copy semantics.

TEST(Geometry_IdentityTransformation, MoveConstruction)

Verifies move construction for geometry identity transformation by checking exact expected values, move semantics.

TEST(Geometry_IdentityTransformation, CopyConstruction)

Verifies copy construction for geometry identity transformation by checking exact expected values, copy semantics.

TEST(Geometry_EmptyIndexGenerator, DefaultConstruction)

Verifies default construction for geometry empty index generator by checking true predicates.

TEST(Geometry_EmptyIndexGenerator, CopyConstruction)

Verifies copy construction for geometry empty index generator by checking true predicates, copy semantics.

TEST(Geometry_EmptyIndexGenerator, MoveConstruction)

Verifies move construction for geometry empty index generator by checking true predicates, move semantics.

TEST(Geometry_EmptyIndexGenerator, AlwaysAtEnd)

Verifies always at end for geometry empty index generator by checking true predicates.

TEST(Geometry_EmptyIndexGenerator, Copy)

Verifies copy for geometry empty index generator by checking true predicates, copy semantics.

TEST(Geometry_EmptyIndexGenerator, Move)

Verifies move for geometry empty index generator by checking true predicates, move semantics.

TEST(Geometry_BoundedIndexGenerator, Construction)

Verifies construction for geometry bounded index generator by checking false predicates.

TEST(Geometry_BoundedIndexGenerator, EmptyRange)

Verifies empty range for geometry bounded index generator by checking true predicates.

TEST(Geometry_BoundedIndexGenerator, CopyConstruction)

Verifies copy construction for geometry bounded index generator by checking true predicates, copy semantics.

TEST(Geometry_BoundedIndexGenerator, MoveConstruction)

Verifies move construction for geometry bounded index generator by checking false predicates, move semantics.

TEST(Geometry_BoundedIndexGenerator, Dereference)

Verifies dereference for geometry bounded index generator by checking exact expected values.

TEST(Geometry_BoundedIndexGenerator, Increment)

Verifies increment for geometry bounded index generator by checking exact expected values, true predicates.

TEST(Geometry_BoundedIndexGenerator, FullIteration)

Verifies full iteration for geometry bounded index generator by checking exact expected values.

TEST(Geometry_BoundedIndexGenerator, Copy)

Verifies copy for geometry bounded index generator by checking true predicates, copy semantics.

TEST(Geometry_BoundedIndexGenerator, Move)

Verifies move for geometry bounded index generator by checking exact expected values, false predicates, move semantics.

TEST(Geometry_BoundedIndexGenerator, SingleElement)

Verifies single element for geometry bounded index generator by checking exact expected values, true predicates, false predicates.

TEST(Geometry_BoundedIndexGenerator, LargeRange)

Verifies large range for geometry bounded index generator by checking exact expected values.

TEST(Geometry_VectorIndexGenerator, EmptyVector)

Verifies empty vector for geometry vector index generator by checking true predicates, move semantics.

TEST(Geometry_VectorIndexGenerator, SingleElement)

Verifies single element for geometry vector index generator by checking exact expected values, true predicates, false predicates.

TEST(Geometry_VectorIndexGenerator, MultipleElements)

Verifies multiple elements for geometry vector index generator by checking exact expected values, true predicates, move semantics.

TEST(Geometry_VectorIndexGenerator, FullIteration)

Verifies full iteration for geometry vector index generator by checking exact expected values, move semantics.

TEST(Geometry_VectorIndexGenerator, Copy)

Verifies copy for geometry vector index generator by checking exact expected values, copy semantics, move semantics.

TEST(Geometry_VectorIndexGenerator, Move)

Verifies move for geometry vector index generator by checking exact expected values, false predicates, move semantics.

TEST(Geometry_SetIndexGenerator, EmptySet)

Verifies empty set for geometry set index generator by checking true predicates, move semantics.

TEST(Geometry_SetIndexGenerator, SingleElement)

Verifies single element for geometry set index generator by checking exact expected values, true predicates, false predicates.

TEST(Geometry_SetIndexGenerator, MultipleElementsSorted)

Verifies multiple elements sorted for geometry set index generator by checking exact expected values, move semantics.

TEST(Geometry_SetIndexGenerator, Copy)

Verifies copy for geometry set index generator by checking exact expected values, false predicates, copy semantics.

TEST(Geometry_SetIndexGenerator, Move)

Verifies move for geometry set index generator by checking exact expected values, false predicates, move semantics.

TEST(Geometry_SetIndexGenerator, ConstructWithConstRef)

Verifies construct with const ref for geometry set index generator by checking exact expected values, false predicates.

TEST(Geometry_UniformGrid, Quadrilateral_2x2)

Verifies quadrilateral 2 x 2 for geometry uniform grid by checking exact expected values.

TEST(Geometry_UniformGrid, Quadrilateral_4x4)

Verifies quadrilateral 4 x 4 for geometry uniform grid by checking exact expected values.

TEST(Geometry_UniformGrid, Quadrilateral_3x5)

Verifies quadrilateral 3 x 5 for geometry uniform grid by checking exact expected values.

TEST(Geometry_UniformGrid, Tetrahedron_2x2x2)

Verifies tetrahedron 2 x 2 x 2 for geometry uniform grid by checking exact expected values.

TEST(Geometry_UniformGrid, Tetrahedron_3x3x3)

Verifies tetrahedron 3 x 3 x 3 for geometry uniform grid by checking exact expected values.

TEST(Geometry_UniformGrid, Hexahedron_2x2x2)

Verifies hexahedron 2 x 2 x 2 for geometry uniform grid by checking exact expected values.

TEST(Geometry_UniformGrid, Hexahedron_3x3x3)

Verifies hexahedron 3 x 3 x 3 for geometry uniform grid by checking exact expected values.

TEST(Geometry_UniformGrid, Hexahedron_4x3x2)

Verifies hexahedron 4 x 3 x 2 for geometry uniform grid by checking exact expected values.

TEST(Geometry_MeshMeasures, TriangleUnitSquare_Area)

16x16 uniform grid spans [0,15]^2, area = 15^2 = 225.

TEST(Geometry_MeshMeasures, TriangleUnitSquare_Perimeter)

Verifies triangle unit square perimeter for geometry mesh measures by checking tolerance-based numerical results.

TEST(Geometry_MeshMeasures, QuadrilateralUnitSquare_Area)

8x8 uniform grid spans [0,7]^2, area = 49.

TEST(Geometry_MeshMeasures, GetMeasure_Dimension2)

Verifies get measure dimension 2 for geometry mesh measures by checking tolerance-based numerical results.

TEST(Geometry_MeshMeasures, GetMeasure_Dimension1)

Verifies get measure dimension 1 for geometry mesh measures.

TEST(Geometry_MeshMeasures, ScaledMesh_Area)

8x8 grid has area = 7^2 = 49; scaled by 2 -> area * 4 = 196.

TEST(Geometry_MeshMeasures, TetrahedronUnitCube_Volume)

3x3x3 grid spans [0,2]^3, volume = 8.

TEST(Geometry_MeshMeasures, HexahedronUnitCube_Volume)

3x3x3 grid spans [0,2]^3, volume = 8.

TEST(Geometry_MeshMeasures, AreaByAttribute)

Verifies area by attribute for geometry mesh measures.

TEST(Geometry_MeshOps, Scale)

Verifies scale for geometry mesh ops by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_MeshOps, CopyConstructor)

Verifies copy constructor for geometry mesh ops by checking exact expected values, copy semantics.

TEST(Geometry_MeshOps, MoveConstructor)

Verifies move constructor for geometry mesh ops by checking exact expected values, move semantics.

TEST(Geometry_MeshOps, MoveAssignment)

Verifies move assignment for geometry mesh ops by checking exact expected values, move semantics.

TEST(Geometry_MeshOps, IsEmpty_Default)

Verifies is empty default for geometry mesh ops by checking true predicates.

TEST(Geometry_MeshOps, IsEmpty_AfterBuild)

Verifies is empty after build for geometry mesh ops by checking false predicates.

TEST(Geometry_MeshOps, NameSetGet)

Verifies name set get for geometry mesh ops by checking exact expected values, true predicates, false predicates.

TEST(Geometry_MeshOps, SetAttribute)

Verifies set attribute for geometry mesh ops by checking exact expected values, true predicates.

TEST(Geometry_MeshOps, SetVertexCoordinates_SingleComponent)

Verifies set vertex coordinates single component for geometry mesh ops by checking tolerance-based numerical results.

TEST(Geometry_MeshOps, SetVertexCoordinates_Vector)

Verifies set vertex coordinates vector for geometry mesh ops by checking tolerance-based numerical results.

TEST(Geometry_MeshOps, FlushClearsCache)

Verifies flush clears cache for geometry mesh ops.

TEST(Geometry_MeshBox, Segment_2Nodes)

Box with segment faces in 2D space.

TEST(Geometry_MeshBox, Segment_4x4Nodes)

Verifies segment 4 x 4 nodes for geometry mesh box by checking exact expected values.

TEST(Geometry_MeshBox, Triangle_3Nodes)

Box with triangular faces in 3D space.

TEST(Geometry_MeshBox, Quadrilateral_3Nodes)

Box with quad faces in 3D space.

TEST(Geometry_MeshBox, Point_2Nodes)

Box with point faces in 1D space (just two endpoints).

TEST(Geometry_MeshBox, Box2D_CoordinatesPositive)

Verifies box 2 D coordinates positive for geometry mesh box.

TEST(Geometry_MeshBox, Box3D_CoordinatesPositive)

Verifies box 3 D coordinates positive for geometry mesh box.

TEST(Geometry_MeshOps, CCL_SingleComponent)

Verifies CCL single component for geometry mesh ops by checking exact expected values.

TEST(Geometry_MeshOps, CCL_WithPredicates)

Verifies CCL with predicates for geometry mesh ops by checking exact expected values.

TEST(Geometry_MeshOps, CCL_ExcludeAll)

Verifies CCL exclude all for geometry mesh ops by checking exact expected values.

TEST(Geometry_MeshOps, CCL_DisconnectByPredicate)

Verifies CCL disconnect by predicate for geometry mesh ops by checking exact expected values.

TEST(Geometry_MeshOps, Trace_ModifiesMesh)

Verifies trace modifies mesh for geometry mesh ops.

TEST(Geometry_MeshOps, IsSurface_2DMesh)

Verifies is surface 2 D mesh for geometry mesh ops by checking false predicates.

TEST(Geometry_MeshOps, IsSurface_Boundary)

Verifies is surface boundary for geometry mesh ops by checking true predicates.

TEST(Geometry_MeshOps, GetPolytope_Cell)

Verifies get polytope cell for geometry mesh ops by checking exact expected values, false predicates.

TEST(Geometry_MeshOps, GetPolytope_Vertex)

Verifies get polytope vertex for geometry mesh ops by checking exact expected values, false predicates.

TEST(Rodin_Geometry_Mesh, 2D_Square_Build)

Verifies 2 D square build for geometry mesh by checking exact expected values.

TEST(Rodin_Geometry_Mesh, 2D_Square_Boundary)

Verifies 2 D square boundary for geometry mesh by checking exact expected values, true predicates, false predicates.

TEST(Rodin_Geometry_Mesh, 2D_Square_Interface)

Verifies 2 D square interface for geometry mesh by checking exact expected values, true predicates, false predicates.

TEST(Rodin_Geometry_Mesh_FuzzyTest, 2D_Square_PolytopeTransformation_1)

Verifies 2 D square polytope transformation 1 for geometry mesh fuzzy test by checking tolerance-based numerical results.

TEST(Rodin_Geometry_Mesh, MultipleTriangles)

Verifies multiple triangles for geometry mesh by checking exact expected values.

TEST(Rodin_Geometry_Mesh, 3D_Tetrahedron)

Verifies 3 D tetrahedron for geometry mesh by checking exact expected values.

TEST(Rodin_Geometry_MinSTCut, SignConventions)

Verifies sign conventions for geometry min ST cut by checking exact expected values.

TEST(Rodin_Geometry_MinSTCut, AllNegativeMomentsAreInside)

Verifies all negative moments are inside for geometry min ST cut by checking exact expected values, true predicates.

TEST(Rodin_Geometry_MinSTCut, AllPositiveMomentsAreOutside)

Verifies all positive moments are outside for geometry min ST cut by checking exact expected values.

TEST(Rodin_Geometry_MinSTCut, NegativeMomentIsInside)

Single isolated cell with a negative moment is labelled Inside.

TEST(Rodin_Geometry_MinSTCut, PositiveMomentIsOutside)

Single isolated cell with a positive moment is labelled Outside.

TEST(Rodin_Geometry_MinSTCut, TwoCellStrongEdgeForcesCommonLabel)

Two cells with conflicting moments (one negative, one positive).

TEST(Rodin_Geometry_MinSTCut, TwoCellWeakEdgeFollowsData)

Same conflicting-moment setup as above but with a weak smoothing.

TEST(Rodin_Geometry_MinSTCut, Checkerboard2x2SmoothsForLargeLambda)

2x2 grid with checkerboard sign pattern:.

TEST(Rodin_Geometry_MinSTCut, UnaryCostMatchesAdvertisedConvention)

Inside cost charges only positive moments, outside only negative.

TEST(Rodin_Geometry_MinSTCut, SingleInteriorFlipIsHealedByStrongLambda)

3x3 grid: center cell has near-zero negative moment, surrounded by.

TEST(Rodin_Geometry_MinSTCut, FarFieldThresholdPinsLabels)

Two cells: moment +0.9 (definitely Outside) and moment -0.9.

TEST(Rodin_Geometry_MinSTCut, CellInBandFixesFarFieldCells)

Three cells in a row. Outer cells are out-of-band (fixed to their.

TEST(Rodin_Geometry_MinSTCut, PerEdgeLambdaSteersCutToWeakestFacets)

1x4 row with a clean sign change between cells 1 and 2.

TEST(Rodin_Geometry_MinSTCut, UnaryScaleShiftsDataVsSmoothingBalance)

Two cells with weak moments straddling zero, joined by a small.

TEST(Rodin_Geometry_MinSTCut, MismatchedInputSizesThrow)

Verifies mismatched input sizes throw for geometry min ST cut by checking exception behavior.

TEST(Rodin_Geometry_MinSTCut, NegativeCapacitiesThrow)

Verifies negative capacities throw for geometry min ST cut by checking exception behavior.

TEST(Rodin_Geometry_MinSTCut, OutOfRangeEdgeThrows)

Verifies out of range edge throws for geometry min ST cut by checking exception behavior.

TEST(Rodin_Geometry_MinSTCut, EnergyMatchesLabelChoiceForUnconnectedCells)

Without edges the unary contribution equals the sum of the.

TEST(Rodin_Geometry_ParametricTransformation, SanityTest_ReferenceTriangle)

Verifies sanity test reference triangle for geometry parametric transformation by checking tolerance-based numerical results.

TEST(Rodin_Geometry_ParametricTransformation, SanityTest_Triangle_1)

Verifies sanity test triangle 1 for geometry parametric transformation by checking tolerance-based numerical results.

TEST(Rodin_Geometry_ParametricTransformation, P2CurvesInterfaceEdge)

Verifies P 2 curves interface edge for geometry parametric transformation by checking tolerance-based numerical results.

TEST(Rodin_Geometry_ParametricTransformation, P3CurvedEdgeImprovesFit)

Verifies P 3 curved edge improves fit for geometry parametric transformation.

TEST(Rodin_Geometry_ParametricTransformation, CurvedTriangleJacobianStaysPositive)

Verifies curved triangle jacobian stays positive for geometry parametric transformation.

TEST(Geometry_PointCloud, DefaultConstruction)

Verifies default construction for geometry point cloud by checking exact expected values.

TEST(Geometry_PointCloud, SizedConstruction2D)

Verifies sized construction 2 D for geometry point cloud by checking exact expected values.

TEST(Geometry_PointCloud, SizedConstruction3D)

Verifies sized construction 3 D for geometry point cloud by checking exact expected values.

TEST(Geometry_PointCloud, PushBack1D)

Verifies push back 1 D for geometry point cloud by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PointCloud, PushBack2D)

Verifies push back 2 D for geometry point cloud by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PointCloud, PushBack3D)

Verifies push back 3 D for geometry point cloud by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PointCloud, PushBackSpatialPoint)

Verifies push back spatial point for geometry point cloud by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PointCloud, ElementAccessReadWrite)

Verifies element access read write for geometry point cloud by checking tolerance-based numerical results.

TEST(Geometry_PointCloud, CopyConstruction)

Verifies copy construction for geometry point cloud by checking tolerance-based numerical results, exact expected values, copy semantics.

TEST(Geometry_PointCloud, MoveConstruction)

Verifies move construction for geometry point cloud by checking tolerance-based numerical results, exact expected values, move semantics.

TEST(Geometry_PointCloud, Resize)

Verifies resize for geometry point cloud by checking exact expected values.

TEST(Geometry_PointCloud, Clear)

Verifies clear for geometry point cloud by checking exact expected values.

TEST(Geometry_PointCloud, GetMatrix)

Verifies get matrix for geometry point cloud by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PointCloud, GetPackedMatrix)

Verifies get packed matrix for geometry point cloud by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PointCloud, MultiplePushBacks)

Verifies multiple push backs for geometry point cloud by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_VertexExt, XY_2DMesh)

Verifies XY 2 D mesh for geometry vertex ext by checking false predicates.

TEST(Geometry_VertexExt, Operator_ParenIndex_2D)

Verifies operator paren index 2 D for geometry vertex ext by checking exact expected values, false predicates.

TEST(Geometry_VertexExt, GetCoordinates_2D)

Verifies get coordinates 2 D for geometry vertex ext by checking exact expected values, false predicates.

TEST(Geometry_VertexExt, XYZ_3DMesh)

Verifies XYZ 3 D mesh for geometry vertex ext by checking false predicates.

TEST(Geometry_VertexExt, GetCoordinates_3D)

Verifies get coordinates 3 D for geometry vertex ext by checking exact expected values, false predicates.

TEST(Geometry_VertexExt, TraverseAll_Triangle)

Verifies traverse all triangle for geometry vertex ext by checking exact expected values.

TEST(Geometry_VertexExt, TraverseAll_Tetrahedron)

Verifies traverse all tetrahedron for geometry vertex ext by checking exact expected values.

TEST(Geometry_FaceExt, BoundaryFace_Triangle)

Verifies boundary face triangle for geometry face ext by checking exact expected values, true predicates, false predicates.

TEST(Geometry_FaceExt, InterfaceFace_Triangle)

Verifies interface face triangle for geometry face ext by checking true predicates, false predicates.

TEST(Geometry_CellExt, CellIteration_Triangle)

Verifies cell iteration triangle for geometry cell ext by checking exact expected values, true predicates.

TEST(Geometry_CellExt, CellIteration_Quadrilateral)

Verifies cell iteration quadrilateral for geometry cell ext by checking exact expected values.

TEST(Geometry_CellExt, CellAdjacency_Triangle)

Verifies cell adjacency triangle for geometry cell ext by checking false predicates.

TEST(Geometry_PolytopeExt, GetGeometry_AllTypes)

Triangle mesh.

TEST(Geometry_PolytopeExt, IsCell_IsFace_IsVertex)

Verifies is cell is face is vertex for geometry polytope ext by checking true predicates, false predicates.

TEST(Geometry_PolytopeExt, GetVertices_Triangle)

Verifies get vertices triangle for geometry polytope ext by checking exact expected values, false predicates.

TEST(Geometry_PolytopeExt, GetVertices_Quadrilateral)

Verifies get vertices quadrilateral for geometry polytope ext by checking exact expected values, false predicates.

TEST(Geometry_PolytopeExt, GetVertices_Tetrahedron)

Verifies get vertices tetrahedron for geometry polytope ext by checking exact expected values, false predicates.

TEST(Geometry_PolytopeKey, DefaultConstruction)

Verifies default construction for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, SizedConstruction)

Verifies sized construction for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, InitializerListConstruction)

Verifies initializer list construction for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, InitializerListConstruction_Segment)

Verifies initializer list construction segment for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, InitializerListConstruction_Hex)

Verifies initializer list construction hex for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, ParenthesisOperator)

Verifies parenthesis operator for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, BracketOperator)

Verifies bracket operator for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, MutableAccess)

Verifies mutable access for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, MutableBracketAccess)

Verifies mutable bracket access for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, Resize)

Verifies resize for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, ResizeShrink)

Verifies resize shrink for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, IteratorRange)

Verifies iterator range for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, ConstIteratorRange)

Verifies const iterator range for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, RangeForLoop)

Verifies range for loop for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, EmptyIteration)

Verifies empty iteration for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, GetVertices)

Verifies get vertices for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, SymmetricHash_SameForPermutations)

Verifies symmetric hash same for permutations for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, SymmetricHash_DifferentForDistinctKeys)

Verifies symmetric hash different for distinct keys for geometry polytope key.

TEST(Geometry_PolytopeKey, SymmetricHash_SegmentPermutations)

Verifies symmetric hash segment permutations for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, SymmetricHash_TetPermutations)

Verifies symmetric hash tet permutations for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, SymmetricEquality_SamePermutations)

Verifies symmetric equality same permutations for geometry polytope key by checking true predicates.

TEST(Geometry_PolytopeKey, SymmetricEquality_Different)

Verifies symmetric equality different for geometry polytope key by checking false predicates.

TEST(Geometry_PolytopeKey, SymmetricEquality_DifferentSizes)

Verifies symmetric equality different sizes for geometry polytope key by checking false predicates.

TEST(Geometry_PolytopeKey, SymmetricEquality_Segments)

Verifies symmetric equality segments for geometry polytope key by checking true predicates.

TEST(Geometry_PolytopeKey, BoostSerialization)

Verifies boost serialization for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, BoostSerialization_Empty)

Verifies boost serialization empty for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeKey, BoostSerialization_MaxSize)

Verifies boost serialization max size for geometry polytope key by checking exact expected values.

TEST(Geometry_PolytopeProject, Segment_Cell)

Verifies segment cell for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Segment_Vertex0)

Verifies segment vertex 0 for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Segment_Vertex1)

Verifies segment vertex 1 for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Triangle_Cell)

Verifies triangle cell for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Triangle_Face0)

Verifies triangle face 0 for geometry polytope project.

TEST(Geometry_PolytopeProject, Triangle_Face1)

Verifies triangle face 1 for geometry polytope project.

TEST(Geometry_PolytopeProject, Triangle_Face2)

Verifies triangle face 2 for geometry polytope project.

TEST(Geometry_PolytopeProject, Triangle_Vertex0)

Verifies triangle vertex 0 for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Triangle_Vertex1)

Verifies triangle vertex 1 for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Triangle_Vertex2)

Verifies triangle vertex 2 for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Quadrilateral_Cell)

Verifies quadrilateral cell for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Quadrilateral_Vertex0)

Verifies quadrilateral vertex 0 for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Tetrahedron_Cell)

Verifies tetrahedron cell for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Tetrahedron_Face0)

Verifies tetrahedron face 0 for geometry polytope project.

TEST(Geometry_PolytopeProject, Tetrahedron_Vertex0)

Verifies tetrahedron vertex 0 for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Pyramid_Cell)

Verifies pyramid cell for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Pyramid_Faces)

Verifies pyramid faces for geometry polytope project.

TEST(Geometry_PolytopeProject, Hexahedron_Cell)

Verifies hexahedron cell for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Hexahedron_Vertex0)

Verifies hexahedron vertex 0 for geometry polytope project by checking tolerance-based numerical results.

TEST(Geometry_PolytopeProject, Triangle_Boundary)

Verifies triangle boundary for geometry polytope project.

TEST(Geometry_PolytopeQuadratureIndex, CachesSingleFormulaPerPolytope)

Verifies caches single formula per polytope for geometry polytope quadrature index by checking exact expected values.

TEST(Geometry_PolytopeQuadratureIndex, DistinguishesQuadratureFormulaKeys)

Verifies distinguishes quadrature formula keys for geometry polytope quadrature index by checking exact expected values.

TEST(Geometry_PolytopeQuadratureIndex, ClearDropsCachedEntries)

Verifies clear drops cached entries for geometry polytope quadrature index by checking exact expected values.

TEST(Geometry_PolytopeQuadratureIndex, MeshMoveConstructorDropsStaleEntries)

Verifies mesh move constructor drops stale entries for geometry polytope quadrature index by checking exact expected values, move semantics.

TEST(Geometry_PolytopeQuadratureIndex, MeshMoveAssignmentDropsStaleEntries)

Verifies mesh move assignment drops stale entries for geometry polytope quadrature index by checking exact expected values, move semantics.

TEST(Geometry_PolytopeQuadratureIndex, ThrowsOnInvalidDimension)

Verifies throws on invalid dimension for geometry polytope quadrature index by checking exception behavior.

TEST(Geometry_PolytopeQuadratureIndex, ThrowsOnOutOfRangePolytopeIndex)

Verifies throws on out of range polytope index for geometry polytope quadrature index by checking exception behavior.

TEST(Geometry_PolytopeQuadratureIndex, ExceedingCapacityDoesNotThrow)

Verifies exceeding capacity does not throw for geometry polytope quadrature index by checking no-throw behavior.

TEST(Geometry_PolytopeQuadratureIndex, RetainsFormulaBeyondFormerCapacity)

Verifies formula entries remain stable beyond the former bounded-cache capacity.

TEST(Geometry_PolytopeQuadratureIndex, PreservesImmediateRepeatAcrossFormulas)

Verifies immediate repeated access after registering several formulas.

TEST(Geometry_PolytopeQuadratureIndex, ConstructsDistinctFormulasConcurrently)

Verifies that concurrent formula lookup constructs each cached entry once.

TEST(Geometry_Polytope, BasicPolytopeAccess)

Verifies basic polytope access for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeIndexAccess)

Verifies polytope index access for geometry polytope by checking false predicates.

TEST(Geometry_Polytope, PolytopeAttributeAccess)

Verifies polytope attribute access for geometry polytope by checking false predicates.

TEST(Geometry_Polytope, PolytopeDimension)

Verifies polytope dimension for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, PolytopeMeshReference)

Verifies polytope mesh reference for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeCopyConstruction)

Verifies polytope copy construction for geometry polytope by checking exact expected values, false predicates, copy semantics.

TEST(Geometry_Polytope, PolytopeCopyAssignment)

Verifies polytope copy assignment for geometry polytope by checking exact expected values, false predicates, copy semantics.

TEST(Geometry_Polytope, PolytopeMoveConstruction)

Verifies polytope move construction for geometry polytope by checking exact expected values, false predicates, move semantics.

TEST(Geometry_Polytope, PolytopeMoveAssignment)

Verifies polytope move assignment for geometry polytope by checking exact expected values, false predicates, move semantics.

TEST(Geometry_Polytope, PolytopeEquality)

Verifies polytope equality for geometry polytope by checking true predicates, false predicates.

TEST(Geometry_Polytope, PolytopeInequality)

Verifies polytope inequality for geometry polytope by checking true predicates, false predicates.

TEST(Geometry_Polytope, Polytope3D_Boundary)

Verifies polytope 3 D boundary for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, Polytope3D_Interface)

Verifies polytope 3 D interface for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, PolytopeBoundaryCount_Triangle)

Verifies polytope boundary count triangle for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, PolytopeBoundaryCount_Quadrilateral)

Verifies polytope boundary count quadrilateral for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, PolytopeInterfaceCount_TwoTriangles)

Verifies polytope interface count two triangles for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, PolytopeConsistentDimension_BoundaryVsInterface)

Verifies polytope consistent dimension boundary vs interface for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, PolytopeIndexUniqueness)

Verifies polytope index uniqueness for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, PolytopeComplexMesh)

Verifies polytope complex mesh for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, PolytopeAccessMultipleTimes)

Verifies polytope access multiple times for geometry polytope by checking exact expected values, true predicates, false predicates.

TEST(Geometry_Polytope, PolytopeGetGeometry_Triangle)

Verifies polytope get geometry triangle for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeGetGeometry_Quadrilateral)

Verifies polytope get geometry quadrilateral for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeGetGeometry_Tetrahedron)

Verifies polytope get geometry tetrahedron for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeIsCell_True)

Verifies polytope is cell true for geometry polytope by checking true predicates, false predicates.

TEST(Geometry_Polytope, PolytopeIsFace_True)

Verifies polytope is face true for geometry polytope by checking true predicates, false predicates.

TEST(Geometry_Polytope, PolytopeIsVertex_True)

Verifies polytope is vertex true for geometry polytope by checking true predicates, false predicates.

TEST(Geometry_Polytope, PolytopeGetVertices_Triangle)

Verifies polytope get vertices triangle for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeGetVertices_Quadrilateral)

Verifies polytope get vertices quadrilateral for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeGetVertices_Tetrahedron)

Verifies polytope get vertices tetrahedron for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeGetVertexIterator)

Verifies polytope get vertex iterator for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeGetMeasure_Triangle)

Verifies polytope get measure triangle for geometry polytope by checking tolerance-based numerical results, false predicates.

TEST(Geometry_Polytope, PolytopeGetMeasure_Quadrilateral)

Verifies polytope get measure quadrilateral for geometry polytope by checking tolerance-based numerical results, false predicates.

TEST(Geometry_Polytope, PolytopeGetMeasure_Segment)

Verifies polytope get measure segment for geometry polytope by checking false predicates.

TEST(Geometry_Polytope, PolytopeGetTransformation)

Verifies polytope get transformation for geometry polytope by checking false predicates.

TEST(Geometry_Polytope, PolytopeComparison_LessThan)

Verifies polytope comparison less than for geometry polytope by checking true predicates, false predicates.

TEST(Geometry_Polytope, PolytopeGetAdjacent)

Verifies polytope get adjacent for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeMultipleCells_BoundaryCount)

Verifies polytope multiple cells boundary count for geometry polytope.

TEST(Geometry_Polytope, Polytope3D_GetVertices_Tetrahedron)

Verifies polytope 3 D get vertices tetrahedron for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, PolytopeMultipleGeometryTypes)

Verifies polytope multiple geometry types for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, CellClass_BasicConstruction)

Verifies cell class basic construction for geometry polytope by checking exact expected values, true predicates, false predicates.

TEST(Geometry_Polytope, CellClass_CopyAndMove)

Verifies cell class copy and move for geometry polytope by checking exact expected values, false predicates, copy semantics.

TEST(Geometry_Polytope, FaceClass_BoundaryVsInterface)

Verifies face class boundary vs interface for geometry polytope by checking true predicates, false predicates.

TEST(Geometry_Polytope, FaceClass_CopyAndMove)

Verifies face class copy and move for geometry polytope by checking exact expected values, false predicates, copy semantics.

TEST(Geometry_Polytope, VertexClass_Basic)

Verifies vertex class basic for geometry polytope by checking exact expected values, true predicates, false predicates.

TEST(Geometry_Polytope, VertexClass_CopyAndMove)

Verifies vertex class copy and move for geometry polytope by checking exact expected values, false predicates, copy semantics.

TEST(Geometry_Polytope, LargeMesh_IndexUniqueness)

Verifies large mesh index uniqueness for geometry polytope by checking exact expected values, true predicates.

TEST(Geometry_Polytope, BoundaryPolytopes_AllEdges)

Verifies boundary polytopes all edges for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, 3D_Wedge_Geometry)

Verifies 3 D wedge geometry for geometry polytope by checking exact expected values, true predicates, false predicates.

TEST(Geometry_Polytope, PolytopeIterator_Increment)

Verifies polytope iterator increment for geometry polytope by checking exact expected values.

TEST(Geometry_Polytope, MeasureConsistency_MultipleAccessess)

Verifies measure consistency multiple accessess for geometry polytope by checking tolerance-based numerical results, false predicates.

TEST(Geometry_Polytope, VertexIterator_AllVertices)

Verifies vertex iterator all vertices for geometry polytope by checking exact expected values, true predicates, false predicates.

TEST(Geometry_Polytope, Comparison_SelfEquality)

Verifies comparison self equality for geometry polytope by checking true predicates, false predicates.

TEST(Geometry_Polytope, GetVertices_ArrayAccess)

Verifies get vertices array access for geometry polytope by checking exact expected values, false predicates.

TEST(Geometry_Polytope, TransformationAccess_NotNull)

Verifies transformation access not null for geometry polytope by checking false predicates.

TEST(Geometry_Polytope, 3D_MultipleTets_BoundaryFaces)

Verifies 3 D multiple tets boundary faces for geometry polytope by checking exact expected values, true predicates.

TEST(Geometry_PolytopeTraitsExt, Point_IsTensorProduct)

Verifies point is tensor product for geometry polytope traits ext by checking true predicates.

TEST(Geometry_PolytopeTraitsExt, Segment_IsBoth)

Verifies segment is both for geometry polytope traits ext by checking true predicates.

TEST(Geometry_PolytopeTraitsExt, Triangle_IsNotTensorProduct)

Verifies triangle is not tensor product for geometry polytope traits ext by checking true predicates, false predicates.

TEST(Geometry_PolytopeTraitsExt, Quadrilateral_IsTensorProduct)

Verifies quadrilateral is tensor product for geometry polytope traits ext by checking true predicates, false predicates.

TEST(Geometry_PolytopeTraitsExt, Tetrahedron_IsNotTensorProduct)

Verifies tetrahedron is not tensor product for geometry polytope traits ext by checking true predicates, false predicates.

TEST(Geometry_PolytopeTraitsExt, Hexahedron_IsTensorProduct)

Verifies hexahedron is tensor product for geometry polytope traits ext by checking true predicates, false predicates.

TEST(Geometry_PolytopeTraitsExt, Pyramid_IsNotTensorProduct)

Verifies pyramid is not tensor product for geometry polytope traits ext by checking false predicates.

TEST(Geometry_PolytopeTraitsExt, Wedge_IsTensorProduct)

Wedge = triangle × segment, so it is a tensor product element.

TEST(Geometry_PolytopeTraitsExt, Hexahedron_Dimension)

Verifies hexahedron dimension for geometry polytope traits ext by checking exact expected values.

TEST(Geometry_PolytopeTraitsExt, Hexahedron_VertexCount)

Verifies hexahedron vertex count for geometry polytope traits ext by checking exact expected values.

TEST(Geometry_PolytopeTraitsExt, Pyramid_VertexCount)

Verifies pyramid vertex count for geometry polytope traits ext by checking exact expected values.

TEST(Geometry_PolytopeTraitsExt, PointCentroid)

Verifies point centroid for geometry polytope traits ext by checking exact expected values.

TEST(Geometry_PolytopeTraitsExt, SegmentCentroid)

Verifies segment centroid for geometry polytope traits ext by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PolytopeTraitsExt, TriangleCentroid)

Verifies triangle centroid for geometry polytope traits ext by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PolytopeTraitsExt, QuadrilateralCentroid)

Verifies quadrilateral centroid for geometry polytope traits ext by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PolytopeTraitsExt, TetrahedronCentroid)

Verifies tetrahedron centroid for geometry polytope traits ext by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PolytopeTraitsExt, PyramidCentroid)

Verifies pyramid centroid for geometry polytope traits ext by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PolytopeTraitsExt, HexahedronCentroid)

Verifies hexahedron centroid for geometry polytope traits ext by checking tolerance-based numerical results, exact expected values.

TEST(Geometry_PolytopeTraitsExt, TriangleHalfSpace_Values)

Verifies triangle half space values for geometry polytope traits ext by checking exact expected values.

TEST(Geometry_PolytopeTraitsExt, QuadrilateralHalfSpace_Values)

Verifies quadrilateral half space values for geometry polytope traits ext by checking exact expected values.

TEST(Geometry_PolytopeTraitsExt, TetrahedronHalfSpace_Values)

Verifies tetrahedron half space values for geometry polytope traits ext by checking exact expected values.

TEST(Geometry_PolytopeTraitsExt, PyramidHalfSpace_Values)

Verifies pyramid half space values for geometry polytope traits ext by checking exact expected values.

TEST(Geometry_PolytopeTraitsExt, HexahedronHalfSpace_Values)

Verifies hexahedron half space values for geometry polytope traits ext by checking exact expected values.

TEST(Geometry_PolytopeTraitsExt, CentroidInsideReferenceElement_Triangle)

Verifies centroid inside reference element triangle for geometry polytope traits ext.

TEST(Geometry_PolytopeTraitsExt, CentroidInsideReferenceElement_Quad)

Verifies centroid inside reference element quad for geometry polytope traits ext.

TEST(Geometry_PolytopeTraitsExt, CentroidInsideReferenceElement_Tet)

Verifies centroid inside reference element tet for geometry polytope traits ext.

TEST(Geometry_PolytopeTraitsExt, CentroidInsideReferenceElement_Pyramid)

Verifies centroid inside reference element pyramid for geometry polytope traits ext.

TEST(Geometry_PolytopeTraitsExt, CentroidInsideReferenceElement_Hex)

Verifies centroid inside reference element hex for geometry polytope traits ext.

TEST(Geometry_PolytopeTraits, PointDimension)

Verifies point dimension for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, PointVertexCount)

Verifies point vertex count for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, PointIsSimplex)

Verifies point is simplex for geometry polytope traits by checking true predicates.

TEST(Geometry_PolytopeTraits, SegmentDimension)

Verifies segment dimension for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, SegmentVertexCount)

Verifies segment vertex count for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, SegmentIsSimplex)

Verifies segment is simplex for geometry polytope traits by checking true predicates.

TEST(Geometry_PolytopeTraits, TriangleDimension)

Verifies triangle dimension for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, TriangleVertexCount)

Verifies triangle vertex count for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, TriangleIsSimplex)

Verifies triangle is simplex for geometry polytope traits by checking true predicates.

TEST(Geometry_PolytopeTraits, QuadrilateralDimension)

Verifies quadrilateral dimension for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, QuadrilateralVertexCount)

Verifies quadrilateral vertex count for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, QuadrilateralIsNotSimplex)

Verifies quadrilateral is not simplex for geometry polytope traits by checking false predicates.

TEST(Geometry_PolytopeTraits, TetrahedronDimension)

Verifies tetrahedron dimension for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, TetrahedronVertexCount)

Verifies tetrahedron vertex count for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, TetrahedronIsSimplex)

Verifies tetrahedron is simplex for geometry polytope traits by checking true predicates.

TEST(Geometry_PolytopeTraits, PyramidDimension)

Verifies pyramid dimension for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, PyramidVertexCount)

Verifies pyramid vertex count for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, PyramidIsNotSimplex)

Verifies pyramid is not simplex for geometry polytope traits by checking false predicates.

TEST(Geometry_PolytopeTraits, WedgeDimension)

Verifies wedge dimension for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, WedgeVertexCount)

Verifies wedge vertex count for geometry polytope traits by checking exact expected values.

TEST(Geometry_PolytopeTraits, WedgeIsNotSimplex)

Verifies wedge is not simplex for geometry polytope traits by checking false predicates.

TEST(Geometry_PolytopeTraits, TriangleVertices)

Verifies triangle vertices for geometry polytope traits.

TEST(Geometry_PolytopeTraits, HalfSpaceAccessible)

Verifies half space accessible for geometry polytope traits.

TEST(Geometry_PolytopeTypes, ArraySize)

Verifies array size for geometry polytope types by checking exact expected values.

TEST(Geometry_PolytopeTypes, ArrayContents)

Verifies array contents for geometry polytope types by checking exact expected values.

TEST(Geometry_PolytopeTypes, IterableArray)

Verifies iterable array for geometry polytope types by checking exact expected values.

TEST(Geometry_PolytopeTransformationIndex, ConstructsEachSlotOnceConcurrently)

Verifies that concurrent lookup constructs each transformation once.

TEST(Geometry_PolytopeTransformationIndex, ClearRebuildsTransformation)

Verifies that clearing the index invalidates cached transformations.

TEST(Geometry_Region, EnumValues)

Test that enum values are distinct.

TEST(Geometry_Region, AssignmentAndComparison)

Verifies assignment and comparison for geometry region by checking exact expected values.

TEST(Geometry_Region, AllValuesAccessible)

Test that all enum values can be assigned.

TEST(Rodin_Geometry_Sharder, BasicSharding_TriangleMesh_2Parts)

Verifies basic sharding triangle mesh 2 parts for geometry sharder by checking exact expected values.

TEST(Rodin_Geometry_Sharder, EveryCellOwnedByExactlyOneShard)

Verifies every cell owned by exactly one shard for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, EveryVertexPresent)

Verifies every vertex present for geometry sharder by checking exact expected values.

TEST(Rodin_Geometry_Sharder, EveryVertexOwnedByExactlyOneShard)

Verifies every vertex owned by exactly one shard for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, GhostCellsAreNeighbors)

Verifies ghost cells are neighbors for geometry sharder by checking true predicates.

TEST(Rodin_Geometry_Sharder, OwnerMapConsistency)

Verifies owner map consistency for geometry sharder.

TEST(Rodin_Geometry_Sharder, HaloMapConsistency)

Verifies halo map consistency for geometry sharder by checking true predicates.

TEST(Rodin_Geometry_Sharder, PolytopeMapConsistency)

Verifies polytope map consistency for geometry sharder by checking exact expected values.

TEST(Rodin_Geometry_Sharder, QuadrilateralMesh)

Verifies quadrilateral mesh for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, MultiplePartitionCounts)

Verifies multiple partition counts for geometry sharder by checking exact expected values.

TEST(Rodin_Geometry_Sharder, IsLocalConsistency)

Verifies is local consistency for geometry sharder by checking exact expected values.

TEST(Rodin_Geometry_Sharder, GetContext)

Verifies get context for geometry sharder.

TEST(Rodin_Geometry_Sharder, SegmentMesh_BasicSharding)

Verifies segment mesh basic sharding for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, SegmentMesh_IsLocalConsistency)

Verifies segment mesh is local consistency for geometry sharder by checking exact expected values.

TEST(Rodin_Geometry_Sharder, TetrahedronMesh_BasicSharding)

Verifies tetrahedron mesh basic sharding for geometry sharder by checking exact expected values.

TEST(Rodin_Geometry_Sharder, TetrahedronMesh_CellOwnershipUniqueness)

Verifies tetrahedron mesh cell ownership uniqueness for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, TetrahedronMesh_GhostCellsAreNeighbors)

Verifies tetrahedron mesh ghost cells are neighbors for geometry sharder by checking true predicates.

TEST(Rodin_Geometry_Sharder, HexahedronMesh_BasicSharding)

Verifies hexahedron mesh basic sharding for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, HexahedronMesh_OwnerMapConsistency)

Verifies hexahedron mesh owner map consistency for geometry sharder.

TEST(Rodin_Geometry_Sharder, PyramidMesh_BasicSharding)

Verifies pyramid mesh basic sharding for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, PyramidMesh_HaloMapConsistency)

Verifies pyramid mesh halo map consistency for geometry sharder by checking true predicates.

TEST(Rodin_Geometry_Sharder, WedgeMesh_BasicSharding)

Verifies wedge mesh basic sharding for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, WedgeMesh_HaloMapConsistency)

Verifies wedge mesh halo map consistency for geometry sharder by checking true predicates.

static auto makeMixed2DMesh() -> Mesh<Context::Local>

Helper to build a mixed 2D mesh with triangles and quadrilaterals.

TEST(Rodin_Geometry_Sharder, Mixed2D_BasicSharding)

Verifies mixed 2 D basic sharding for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, Mixed2D_VertexOwnershipUniqueness)

Verifies mixed 2 D vertex ownership uniqueness for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, Mixed2D_PolytopeMapConsistency)

Verifies mixed 2 D polytope map consistency for geometry sharder by checking exact expected values.

static auto makeMixed3DMesh() -> Mesh<Context::Local>

Helper to build a mixed 3D mesh with tetrahedra and wedges.

TEST(Rodin_Geometry_Sharder, Mixed3D_BasicSharding)

Verifies mixed 3 D basic sharding for geometry sharder by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Sharder, Mixed3D_VertexCoverage)

Verifies mixed 3 D vertex coverage for geometry sharder by checking exact expected values.

TEST(Rodin_Geometry_Sharder, Mixed3D_IsLocalConsistency)

Verifies mixed 3 D is local consistency for geometry sharder by checking exact expected values.

static auto makeLargerMixed2DMesh() -> Mesh<Context::Local>

Builds a larger mixed 2D mesh: 4 triangles + 2 quadrilaterals.

TEST(Rodin_Geometry_Sharder, LargerMixed2D_MultiplePartitions)

Verifies larger mixed 2 D multiple partitions for geometry sharder by checking exact expected values.

TEST(Rodin_Geometry_Sharder, AllUniformGrid3D_MultiplePartitions)

Test all 3D uniform grid types with multiple partition counts.

TEST(Rodin_Geometry_Sharder, HDF5_ShardSaveLoad_TopologyRoundTrip)

Verifies that each shard's vertex and cell counts are preserved through an HDF5 save/load round-trip.

TEST(Rodin_Geometry_Sharder, HDF5_ShardSaveLoad_Reconcile_GlobalConsistency)

Verifies global mesh consistency after HDF5 shard save/load.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_AllOwned)

Builds a shard from a parent mesh containing two triangles forming a unit square and includes all entities as owned.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_MixedStates)

Builds two shards from a 4-triangle mesh and verifies ownership, shared, and ghost state for vertices and cells.

TEST(Rodin_Geometry_Shard, Builder_DirectMode_SingleTriangle)

Tests direct construction of a shard with explicit vertex and polytope insertion.

TEST(Rodin_Geometry_Shard, Builder_DirectMode_VertexIdempotent)

Verifies that inserting the same global vertex twice in direct mode is idempotent and returns the same local index.

TEST(Rodin_Geometry_Shard, PolytopeMap_ParentMode)

Verifies the bidirectional polytope map after building a shard from a parent mesh.

TEST(Rodin_Geometry_Shard, PolytopeMap_DirectMode)

Verifies the bidirectional polytope map after building a shard in direct mode.

TEST(Rodin_Geometry_Shard, GetState)

Verifies getState() returns the correct per-entity state vectors.

TEST(Rodin_Geometry_Shard, MoveConstructor)

Verifies move constructor for geometry shard by checking exact expected values, true predicates, move semantics.

TEST(Rodin_Geometry_Shard, MoveAssignment)

Verifies move assignment for geometry shard by checking exact expected values, true predicates, move semantics.

TEST(Rodin_Geometry_Shard, CopyConstructor)

Verifies copy constructor for geometry shard by checking exact expected values, true predicates, copy semantics.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_IncludeIdempotent)

Verifies builder parent mode include idempotent for geometry shard by checking exact expected values, true predicates, false predicates.

TEST(Rodin_Geometry_Shard, OwnerAndHaloMetadata_DirectMode)

Verifies owner and halo metadata direct mode for geometry shard by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_Quadrilateral)

Verifies builder parent mode quadrilateral for geometry shard by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_Segment)

Verifies builder parent mode segment for geometry shard by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_Tetrahedron)

Verifies builder parent mode tetrahedron for geometry shard by checking exact expected values.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_Hexahedron)

Verifies builder parent mode hexahedron for geometry shard by checking exact expected values.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_Pyramid)

Verifies builder parent mode pyramid for geometry shard by checking exact expected values.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_Wedge)

Verifies builder parent mode wedge for geometry shard by checking exact expected values.

TEST(Rodin_Geometry_Shard, Builder_DirectMode_Quadrilateral)

Verifies builder direct mode quadrilateral for geometry shard by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Shard, Builder_DirectMode_Segment)

Verifies builder direct mode segment for geometry shard by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Shard, Builder_DirectMode_Tetrahedron)

Verifies builder direct mode tetrahedron for geometry shard by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Shard, Builder_DirectMode_Hexahedron)

Verifies builder direct mode hexahedron for geometry shard by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Shard, Builder_DirectMode_Pyramid)

Verifies builder direct mode pyramid for geometry shard by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_Mixed2D_TriQuad)

Build a mixed mesh: 2 triangles + 1 quadrilateral sharing vertices.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_Mixed2D_Partial)

Same mixed mesh but only include one triangle and one quad, with.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_Mixed3D_TetWedge)

3D mixed mesh: 1 tetrahedron + 1 wedge sharing a triangular face.

TEST(Rodin_Geometry_Shard, Builder_DirectMode_Wedge)

Verifies builder direct mode wedge for geometry shard by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Shard, Builder_DirectMode_Mixed2D)

Verifies builder direct mode mixed 2 D for geometry shard by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_AttributePreservation)

Tests that Builder::include() preserves entity attributes from the parent mesh after shard finalization.

TEST(Rodin_Geometry_Shard, Builder_ParentMode_ConnectivityPreservation)

Tests that shard-local cell-to-vertex connectivity matches the parent mesh connectivity when mapped through the PolytopeMap.

TEST(Rodin_Geometry_Shard, Builder_DirectMode_Mixed3D)

Tests direct-mode construction of a mixed 3D shard containing one tetrahedron and one wedge that share a triangular face.

TEST(Geometry_SubMesh, BuildFromBoundaryFaces)

Verifies build from boundary faces for geometry sub mesh by checking true predicates.

TEST(Geometry_SubMesh, GetParent)

Verifies get parent for geometry sub mesh by checking exact expected values.

TEST(Geometry_SubMesh, GetAncestors)

Verifies get ancestors for geometry sub mesh by checking exact expected values.

TEST(Geometry_SubMesh, PolytopeMap)

Verifies polytope map for geometry sub mesh by checking exact expected values.

TEST(Geometry_SubMesh, VertexPolytopeMap)

Verifies vertex polytope map for geometry sub mesh by checking exact expected values.

TEST(Geometry_SubMesh, SkinProducesSubmesh)

Verifies skin produces submesh for geometry sub mesh by checking exact expected values, true predicates.

TEST(Geometry_SubMesh, TrimSingleAttribute)

Verifies trim single attribute for geometry sub mesh by checking true predicates.

TEST(Geometry_SubMesh, KeepSingleAttribute)

Verifies keep single attribute for geometry sub mesh by checking exact expected values, true predicates.

TEST(Geometry_SubMesh, TrimAndKeepAreComplementary)

Verifies trim and keep are complementary for geometry sub mesh by checking exact expected values.

TEST(Geometry_SubMesh, MoveConstruction)

Verifies move construction for geometry sub mesh by checking exact expected values, true predicates, move semantics.

TEST(Geometry_SubMesh, IsSubMeshFlag)

Verifies is sub mesh flag for geometry sub mesh by checking true predicates, false predicates.

TEST(Geometry_SubMesh, AsSubMesh)

Verifies as sub mesh for geometry sub mesh by checking exact expected values, true predicates.

TEST(Rodin_Geometry_Mesh_UniformGrid, InvalidDimensions)

Verifies that invalid grid dimensions raise a member-function exception.

TEST(Rodin_Geometry_Mesh_UniformGrid, SanityTest)

Verifies sanity test for geometry mesh uniform grid by checking exact expected values.

TEST(Rodin_Geometry_Mesh_UniformGrid, Pyramid_OneBrick)

Verifies pyramid one brick for geometry mesh uniform grid by checking exact expected values.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree1_Scalar)

Test saving and loading H1 GridFunction with degree 1 (scalar)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree2_Scalar)

Test saving and loading H1 GridFunction with degree 2 (scalar)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree3_Scalar)

Test saving and loading H1 GridFunction with degree 3 (scalar)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadFile_H1_Degree2_Scalar)

Test saving H1 GridFunction to file and loading it back.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree4_Triangle)

Test H1 degree 4 on triangle mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree5_Triangle)

Test H1 degree 5 on triangle mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree6_Triangle)

Test H1 degree 6 on triangle mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree4_Quadrilateral)

Test H1 degree 4 on quadrilateral mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree5_Quadrilateral)

Test H1 degree 5 on quadrilateral mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree6_Quadrilateral)

Test H1 degree 6 on quadrilateral mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree4_Tetrahedron)

Test H1 degree 4 on tetrahedron mesh (3D)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree5_Tetrahedron)

Test H1 degree 5 on tetrahedron mesh (3D)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree6_Tetrahedron)

Test H1 degree 6 on tetrahedron mesh (3D)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree4_Mixed2D)

Test H1 degree 4 on mixed 2D mesh (triangles and quads)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree5_Mixed2D)

Test H1 degree 5 on mixed 2D mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree6_Mixed2D)

Test H1 degree 6 on mixed 2D mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree1_Quadrilateral)

Test H1 degree 1 on quadrilateral mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree2_Quadrilateral)

Test H1 degree 2 on quadrilateral mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree1_Tetrahedron)

Test H1 degree 1 on tetrahedron mesh (3D)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree2_Tetrahedron)

Test H1 degree 2 on tetrahedron mesh (3D)

TEST_P(H1Degree2RoundTrip3DGeometryCoverage, SaveLoadRoundTrip)

Verifies save load round trip for H1 degree 2 round trip 3 D geometry coverage by checking tolerance-based numerical results, exact expected values, grid-function projection.

INSTANTIATE_TEST_SUITE_P(All3DPolytopes, H1Degree2RoundTrip3DGeometryCoverage, ::testing::Values(Polytope::Type::Tetrahedron, Polytope::Type::Hexahedron, Polytope::Type::Pyramid, Polytope::Type::Wedge), (const ::testing::TestParamInfo<Polytope::Type>&info) { return geometryName(info.param);})

Instantiates H1 Degree 2 Round Trip 3 D Geometry Coverage over the All 3 D Polytopes parameter coverage.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree1_Triangle_Large)

Verifies save load round trip H1 degree 1 triangle large for IO MFEM H1 grid function by checking tolerance-based numerical results, exact expected values, grid-function projection.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree2_Triangle_Large)

Test H1 degree 2 on triangle mesh with >= 16 elements.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree1_Mixed2D)

Test H1 degree 1 on mixed 2D mesh (triangles and quads)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree2_Mixed2D)

Test H1 degree 2 on mixed 2D mesh.

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree1_Segment)

Test H1 degree 1 on segment mesh (1D)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree2_Segment)

Test H1 degree 2 on segment mesh (1D)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree3_Segment)

Test H1 degree 3 on segment mesh (1D)

TEST(Rodin_IO_MFEM_H1_GridFunction, SaveLoadRoundTrip_H1_Degree4_Segment)

Test H1 degree 4 on segment mesh (1D)

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMStringFixture_H1_Degree1_Triangle_Scalar_ByNodes)

Verifies load MFEM string fixture H1 degree 1 triangle scalar by nodes for IO MFEM H1 grid function by checking grid-function projection.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree1_Scalar_ByNodes)

Verifies load MFEM file fixtures H1 degree 1 scalar by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree2_Scalar_ByNodes)

Verifies load MFEM file fixtures H1 degree 2 scalar by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree3_Scalar_ByNodes)

Verifies load MFEM file fixtures H1 degree 3 scalar by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree4_Scalar_ByNodes)

Verifies load MFEM file fixtures H1 degree 4 scalar by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree5_Scalar_ByNodes)

Verifies load MFEM file fixtures H1 degree 5 scalar by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree6_Scalar_ByNodes)

Verifies load MFEM file fixtures H1 degree 6 scalar by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree1_Scalar)

Verifies round trip MFEM file fixtures H1 degree 1 scalar for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree2_Scalar)

Verifies round trip MFEM file fixtures H1 degree 2 scalar for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree3_Scalar)

Verifies round trip MFEM file fixtures H1 degree 3 scalar for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree4_Scalar)

Verifies round trip MFEM file fixtures H1 degree 4 scalar for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree5_Scalar)

Verifies round trip MFEM file fixtures H1 degree 5 scalar for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree6_Scalar)

Verifies round trip MFEM file fixtures H1 degree 6 scalar for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree1_Vector_ByNodes)

Verifies load MFEM file fixtures H1 degree 1 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree2_Vector_ByNodes)

Verifies load MFEM file fixtures H1 degree 2 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree3_Vector_ByNodes)

Verifies load MFEM file fixtures H1 degree 3 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree4_Vector_ByNodes)

Verifies load MFEM file fixtures H1 degree 4 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree5_Vector_ByNodes)

Verifies load MFEM file fixtures H1 degree 5 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadMFEMFileFixtures_H1_Degree6_Vector_ByNodes)

Verifies load MFEM file fixtures H1 degree 6 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree1_Vector_ByNodes)

Verifies round trip MFEM file fixtures H1 degree 1 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree2_Vector_ByNodes)

Verifies round trip MFEM file fixtures H1 degree 2 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree3_Vector_ByNodes)

Verifies round trip MFEM file fixtures H1 degree 3 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree4_Vector_ByNodes)

Verifies round trip MFEM file fixtures H1 degree 4 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree5_Vector_ByNodes)

Verifies round trip MFEM file fixtures H1 degree 5 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree6_Vector_ByNodes)

Verifies round trip MFEM file fixtures H1 degree 6 vector by nodes for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadByVDimPrintByNodesMFEMFileFixtures_H1_Degree1_Vector)

Verifies load by V dim print by nodes MFEM file fixtures H1 degree 1 vector for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadByVDimPrintByNodesMFEMFileFixtures_H1_Degree2_Vector)

Verifies load by V dim print by nodes MFEM file fixtures H1 degree 2 vector for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadByVDimPrintByNodesMFEMFileFixtures_H1_Degree3_Vector)

Verifies load by V dim print by nodes MFEM file fixtures H1 degree 3 vector for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadByVDimPrintByNodesMFEMFileFixtures_H1_Degree4_Vector)

Verifies load by V dim print by nodes MFEM file fixtures H1 degree 4 vector for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadByVDimPrintByNodesMFEMFileFixtures_H1_Degree5_Vector)

Verifies load by V dim print by nodes MFEM file fixtures H1 degree 5 vector for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, LoadByVDimPrintByNodesMFEMFileFixtures_H1_Degree6_Vector)

Verifies load by V dim print by nodes MFEM file fixtures H1 degree 6 vector for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree1_Vector_ByVDim)

Verifies round trip MFEM file fixtures H1 degree 1 vector by V dim for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree2_Vector_ByVDim)

Verifies round trip MFEM file fixtures H1 degree 2 vector by V dim for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree3_Vector_ByVDim)

Verifies round trip MFEM file fixtures H1 degree 3 vector by V dim for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree4_Vector_ByVDim)

Verifies round trip MFEM file fixtures H1 degree 4 vector by V dim for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree5_Vector_ByVDim)

Verifies round trip MFEM file fixtures H1 degree 5 vector by V dim for IO MFEM H1 grid function.

TEST(Rodin_IO_MFEM_H1_GridFunction, RoundTripMFEMFileFixtures_H1_Degree6_Vector_ByVDim)

Verifies round trip MFEM file fixtures H1 degree 6 vector by V dim for IO MFEM H1 grid function.

TEST(Rodin_IO_HDF5, MeshRoundTrip)

Verifies mesh round trip for IO HDF 5 by checking exact expected values.

TEST(Rodin_IO_HDF5, MeshPersistenceNoXDMF)

The HDF5 persistence path (mesh.save) must NOT write /Mesh/XDMF datasets.

TEST(Rodin_IO_HDF5, GridFunctionPersistenceRawDOFs)

The HDF5 persistence path (gf.save) must write raw DOF vector data,.

TEST(Rodin_IO_HDF5, XDMFVisualizationTopology)

The XDMF visualization path must write only minimal visualization data.

TEST(Rodin_IO_HDF5, XDMFQuadraticTriangleVisualizationTopology)

Verifies XDMF quadratic triangle visualization topology for IO HDF 5 by checking exact expected values, true predicates.

TEST_P(Rodin_IO_HDF5_QuadraticXDMF, SupportedQuadraticTopology)

Verifies supported quadratic topology for IO HDF 5 quadratic XDMF by checking exact expected values, true predicates, false predicates.

TEST_P(Rodin_IO_HDF5_QuadraticXDMF, ForcedMixedQuadraticTopologyUsesXDMFIds)

Verifies forced mixed quadratic topology uses XDMF ids for IO HDF 5 quadratic XDMF by checking exact expected values.

TEST(Rodin_IO_HDF5, XDMFMixedLinearAndCurvedCellsUsesMixedTopology)

Verifies XDMF mixed linear and curved cells uses mixed topology for IO HDF 5 by checking exact expected values.

TEST(Rodin_IO_HDF5, XDMFCurvedAttributesEvaluateOnVisualizationPoints)

Verifies XDMF curved attributes evaluate on visualization points for IO HDF 5 by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_IO_HDF5, XDMFShardWritesOwnedCurvedCellsOnly)

Verifies XDMF shard writes owned curved cells only for IO HDF 5 by checking exact expected values.

INSTANTIATE_TEST_SUITE_P(Rodin_IO_HDF5, Rodin_IO_HDF5_QuadraticXDMF, testing::Values(QuadraticXDMFCase{Polytope::Type::Segment, 34u, 3u}, QuadraticXDMFCase{Polytope::Type::Triangle, 36u, 6u}, QuadraticXDMFCase{Polytope::Type::Quadrilateral, 35u, 9u}, QuadraticXDMFCase{Polytope::Type::Tetrahedron, 38u, 10u}, QuadraticXDMFCase{Polytope::Type::Pyramid, 39u, 13u}, QuadraticXDMFCase{Polytope::Type::Wedge, 41u, 18u}, QuadraticXDMFCase{Polytope::Type::Hexahedron, 50u, 27u}))

Instantiates IO HDF 5 Quadratic XDMF over the IO HDF 5 parameter coverage.

TEST(Rodin_IO_HDF5, XDMFVisualizationEvaluatedAttributes)

The XDMF visualization path must write evaluated vertex data,.

TEST(Rodin_IO_HDF5, GridFunctionStandalone)

Verifies grid function standalone for IO HDF 5 by checking exact expected values.

TEST(Rodin_IO_HDF5, XDMFWriteAndClose)

Use a dedicated subdirectory for test output.

TEST_P(MeshFormatCoverage, MEDITRoundTrip)

Verifies MEDIT round trip for mesh format coverage.

TEST_P(MeshFormatCoverage, MFEMRoundTrip)

Verifies MFEM round trip for mesh format coverage.

TEST_P(MeshAttributeRegression, MEDITPreservesDimensionAttributes)

Verifies MEDIT preserves dimension attributes for mesh attribute regression.

TEST_P(MeshAttributeRegression, MFEMPreservesDimensionAttributes)

Verifies MFEM preserves dimension attributes for mesh attribute regression.

TEST(Rodin_IO_MeshLoader, MEDITLoadSaveLoadPreservesCanonicalAttributes)

Verifies MEDIT load save load preserves canonical attributes for IO mesh loader by checking exact expected values.

INSTANTIATE_TEST_SUITE_P(Dimensions, MeshAttributeRegression, ::testing::Values(1, 2, 3), (const ::testing::TestParamInfo<size_t>&info) { return "Dim"+std::to_string(info.param)+"D";})

Instantiates Mesh Attribute Regression over the Dimensions parameter coverage.

INSTANTIATE_TEST_SUITE_P(AllSupportedGeometries, MeshFormatCoverage, ::testing::Values(Polytope::Type::Point, Polytope::Type::Segment, Polytope::Type::Triangle, Polytope::Type::Quadrilateral, Polytope::Type::Tetrahedron, Polytope::Type::Pyramid, Polytope::Type::Hexahedron, Polytope::Type::Wedge), (const ::testing::TestParamInfo<Polytope::Type>&info) { return geometryName(info.param);})

Instantiates Mesh Format Coverage over the All Supported Geometries parameter coverage.

TEST(Rodin_IO_MeshLoader, SanityTest_MEDIT_2D_Square)

Verifies sanity test MEDIT 2 D square for IO mesh loader by checking exact expected values.

TEST(Rodin_IO_MeshLoader, SanityTest_MFEM_2D_Square)

Verifies sanity test MFEM 2 D square for IO mesh loader by checking exact expected values.

TEST(Rodin_IO_MeshLoader, SanityTest_MFEM_2D_StarSquare)

Verifies sanity test MFEM 2 D star square for IO mesh loader by checking exact expected values.

TEST_P(P0MFEMGridFunctionCoverage, ScalarRoundTrip)

Verifies scalar round trip for P0 MFEM grid function coverage by checking tolerance-based numerical results, exact expected values.

INSTANTIATE_TEST_SUITE_P(AllSupportedGeometries, P0MFEMGridFunctionCoverage, ::testing::Values(Polytope::Type::Point, Polytope::Type::Segment, Polytope::Type::Triangle, Polytope::Type::Quadrilateral, Polytope::Type::Tetrahedron, Polytope::Type::Pyramid, Polytope::Type::Hexahedron, Polytope::Type::Wedge), (const ::testing::TestParamInfo<Polytope::Type>&info) { return geometryName(info.param);})

Instantiates P0 MFEM Grid Function Coverage over the All Supported Geometries parameter coverage.

TEST(Rodin_IO_MFEM_P0_GridFunction, ScalarMultilineLoad)

Verifies scalar multiline load for IO MFEM P0 grid function by checking tolerance-based numerical results.

TEST(Rodin_IO_MFEM_P1_GridFunction, SaveLoadRoundTrip_Triangle)

Test saving and loading P1 GridFunction on triangle mesh (2D)

TEST(Rodin_IO_MFEM_P1_GridFunction, SaveLoadRoundTrip_Quadrilateral)

Test saving and loading P1 GridFunction on quadrilateral mesh (2D)

TEST(Rodin_IO_MFEM_P1_GridFunction, SaveLoadRoundTrip_Tetrahedron)

Test saving and loading P1 GridFunction on tetrahedron mesh (3D)

TEST(Rodin_IO_MFEM_P1_GridFunction, SaveLoadRoundTrip_Wedge)

Test saving and loading P1 GridFunction on wedge mesh (3D)

TEST(Rodin_IO_MFEM_P1_GridFunction, SaveLoadRoundTrip_Pyramid)

Verifies save load round trip pyramid for IO MFEM P1 grid function by checking tolerance-based numerical results, exact expected values, grid-function projection.

TEST(Rodin_IO_MFEM_P1_GridFunction, SaveLoadRoundTrip_Segment)

Test saving and loading P1 GridFunction on segment mesh (1D)

TEST(Rodin_IO_MFEM_P1_GridFunction, SaveLoadRoundTrip_Mixed2D)

Test saving and loading P1 GridFunction on mixed 2D mesh.

TEST(Rodin_IO_MFEM_P1_GridFunction, SaveLoadFile)

Test file-based I/O for P1 GridFunction.

TEST_P(P1MEDITGridFunctionCoverage, ScalarRoundTrip)

Verifies scalar round trip for P1 MEDIT grid function coverage by checking tolerance-based numerical results, exact expected values.

INSTANTIATE_TEST_SUITE_P(AllSupportedGeometries, P1MEDITGridFunctionCoverage, ::testing::Values(Polytope::Type::Point, Polytope::Type::Segment, Polytope::Type::Triangle, Polytope::Type::Quadrilateral, Polytope::Type::Tetrahedron, Polytope::Type::Pyramid, Polytope::Type::Hexahedron, Polytope::Type::Wedge), (const ::testing::TestParamInfo<Polytope::Type>&info) { return meditGeometryName(info.param);})

Instantiates P1 MEDIT Grid Function Coverage over the All Supported Geometries parameter coverage.

TEST(Rodin_IO_MEDIT_P1_GridFunction, Vector3DRoundTrip)

Verifies vector 3 D round trip for IO MEDIT P1 grid function by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_MMG_Mesh, DefaultConstruction)

Verifies default construction for MMG mesh by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh, UniformGridConstruction)

Verifies uniform grid construction for MMG mesh by checking exact expected values, false predicates.

TEST(Rodin_MMG_Mesh, SetCorner)

Verifies set corner for MMG mesh by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh, SetRidge)

Verifies set ridge for MMG mesh by checking exact expected values.

TEST(Rodin_MMG_Mesh, SetRequiredVertex)

Verifies set required vertex for MMG mesh by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh, SetRequiredEdge)

Verifies set required edge for MMG mesh by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh, SetRequiredTriangle)

Verifies set required triangle for MMG mesh by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh, SetRequiredTetrahedron)

Verifies set required tetrahedron for MMG mesh by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh, CopyConstruction)

Verifies copy construction for MMG mesh by checking exact expected values, true predicates, copy semantics.

TEST(Rodin_MMG_Mesh, MoveConstruction)

Verifies move construction for MMG mesh by checking exact expected values, move semantics.

TEST(Rodin_MMG_Mesh, MoveAssignment)

Verifies move assignment for MMG mesh by checking exact expected values, move semantics.

TEST(Rodin_MMG_Mesh, MoveFromParent)

Verifies move from parent for MMG mesh by checking exact expected values, move semantics.

TEST(Rodin_MMG_Mesh_Builder, TriangleMeshWithMMGMetadata)

Verifies triangle mesh with MMG metadata for MMG mesh builder by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh_Builder, BuilderWithAllMMGMetadata)

Verifies builder with all MMG metadata for MMG mesh builder by checking exact expected values.

TEST(Rodin_MMG_Mesh_IO, SaveLoadMEDITRoundtrip)

Verifies save load MEDIT roundtrip for MMG mesh IO by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh_IO, SaveLoadMEDITRequiredTriangles2D)

Verifies save load MEDIT required triangles 2 D for MMG mesh IO by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh_IO, SaveLoadMEDITRequiredTriangles3D)

Verifies save load MEDIT required triangles 3 D for MMG mesh IO by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh_IO, SaveLoadMEDITRequiredEntities3D)

Verifies save load MEDIT required entities 3 D for MMG mesh IO by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh_IO, SaveLoadMEDITEmptyMetadata)

Verifies save load MEDIT empty metadata for MMG mesh IO by checking exact expected values.

TEST(Rodin_MMG_MMG5, RodinToMeshAndBack2D)

Verifies rodin to mesh and back 2 D for MMG MMG 5 by checking exact expected values.

TEST(Rodin_MMG_MMG5, RodinToMeshPreservesMMGMetadata)

Verifies rodin to mesh preserves MMG metadata for MMG MMG 5 by checking exact expected values, true predicates.

TEST(Rodin_MMG_MMG5, RequiredTrianglesRoundtrip2D)

Verifies required triangles roundtrip 2 D for MMG MMG 5 by checking exact expected values, true predicates.

TEST(Rodin_MMG_MMG5, RequiredEntitiesRoundtrip2D)

Verifies required entities roundtrip 2 D for MMG MMG 5 by checking exact expected values, true predicates.

TEST(Rodin_MMG_MMG5, RequiredTrianglesRoundtrip3DWithoutFaceAttributes)

Verifies required triangles roundtrip 3 D without face attributes for MMG MMG 5 by checking exact expected values.

TEST(Rodin_MMG_MMG5, RequiredTrianglesRoundtrip3DPreservesBoundaryMetadataWithFaceAttributes)

Verifies required triangles roundtrip 3 D preserves boundary metadata with face attributes for MMG MMG 5 by checking exact expected values, true predicates.

TEST(Rodin_MMG_MMG5, RequiredEntitiesRoundtrip3D)

Verifies required entities roundtrip 3 D for MMG MMG 5 by checking exact expected values, true predicates.

TEST(Rodin_MMG_Optimizer, Optimize2DTriangleMesh)

Verifies optimize 2 D triangle mesh for MMG optimizer by checking exact expected values, false predicates.

TEST(Rodin_MMG_Optimizer, FluentAPI)

Verifies fluent API for MMG optimizer by checking false predicates.

TEST(Rodin_MMG_Optimizer, OptimizeWithCorners)

Verifies optimize with corners for MMG optimizer by checking false predicates.

TEST(Rodin_MMG_Optimizer, PreservesRequiredTriangles2D)

Verifies preserves required triangles 2 D for MMG optimizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_Optimizer, PreservesRequiredTriangles3D)

Verifies preserves required triangles 3 D for MMG optimizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_Optimizer, PreservesRequiredEntities2D)

Verifies preserves required entities 2 D for MMG optimizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_Optimizer, PreservesRequiredEntities3D)

Verifies preserves required entities 3 D for MMG optimizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_Adapt, UniformSizeMap2D)

Verifies uniform size map 2 D for MMG adapt by checking exact expected values, false predicates.

TEST(Rodin_MMG_Adapt, VariableSizeMap2D)

Verifies variable size map 2 D for MMG adapt by checking false predicates.

TEST(Rodin_MMG_Adapt, FluentAPI)

Verifies fluent API for MMG adapt by checking false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, CircleLevelSet2D)

Verifies circle level set 2 D for MMG level set discretizer by checking exact expected values, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, FluentAPI)

Verifies fluent API for MMG level set discretizer by checking false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitMaterial)

Verifies no split material for MMG level set discretizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, SetLevelSetValue)

Verifies set level set value for MMG level set discretizer by checking false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, PreservesRequiredTriangles2D)

Verifies preserves required triangles 2 D for MMG level set discretizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, PreservesRequiredTriangles3D)

Verifies preserves required triangles 3 D for MMG level set discretizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, PreservesRequiredEntities2D)

Verifies preserves required entities 2 D for MMG level set discretizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, PreservesUncutRequiredEntityGeometry2D)

Verifies preserves uncut required entity geometry 2 D for MMG level set discretizer by checking true predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, PreservesRequiredEntities3D)

Verifies preserves required entities 3 D for MMG level set discretizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, PreservesUncutRequiredEntityGeometry3D)

Verifies preserves uncut required entity geometry 3 D for MMG level set discretizer by checking true predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitDoesNotPreserveCutRequiredEdge2D)

Verifies no split does not preserve cut required edge 2 D for MMG level set discretizer by checking true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitDoesNotPreserveCutRequiredTriangle2D)

Verifies no split does not preserve cut required triangle 2 D for MMG level set discretizer by checking true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitDoesNotPreserveIndividuallyLabeledCutTriangle2D)

Verifies no split does not preserve individually labeled cut triangle 2 D for MMG level set discretizer by checking true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitDoesNotPreserveCutRequiredEdge3D)

Verifies no split does not preserve cut required edge 3 D for MMG level set discretizer by checking true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitDoesNotPreserveCutRequiredTriangle3D)

Verifies no split does not preserve cut required triangle 3 D for MMG level set discretizer by checking true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitAdjacentTetrahedraDoesNotPreserveCutTriangle3D)

Verifies no split adjacent tetrahedra does not preserve cut triangle 3 D for MMG level set discretizer by checking true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitAdjacentTetrahedraDoesNotPreserveLabeledRequiredCutTriangle3D)

Verifies no split adjacent tetrahedra does not preserve labeled required cut triangle 3 D for MMG level set discretizer by checking true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitRequiredAdjacentTetrahedraDoesNotPreserveCutTriangle3D)

Verifies no split required adjacent tetrahedra does not preserve cut triangle 3 D for MMG level set discretizer by checking true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitRequiredTriangleClosureDoesNotPreserveCutTriangle3D)

Verifies no split required triangle closure does not preserve cut triangle 3 D for MMG level set discretizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitRequiredFullTriangleClosureDoesNotPreserveCutTriangle3D)

Verifies no split required full triangle closure does not preserve cut triangle 3 D for MMG level set discretizer by checking exact expected values, true predicates, false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitDoesNotPreserveIndividuallyLabeledCutTriangle3D)

Verifies no split does not preserve individually labeled cut triangle 3 D for MMG level set discretizer by checking false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitDoesNotPreserveIndividuallyLabeledRequiredCutTriangle3D)

Verifies no split does not preserve individually labeled required cut triangle 3 D for MMG level set discretizer by checking false predicates.

TEST(Rodin_MMG_LevelSetDiscretizer, NoSplitDoesNotPreserveCutRequiredTetrahedron3D)

Verifies no split does not preserve cut required tetrahedron 3 D for MMG level set discretizer by checking true predicates, false predicates.

TEST(Rodin_MMG_Common, SplitMapConstruction)

Verifies split map construction for MMG common by checking exact expected values, true predicates.

TEST(Rodin_MMG_GridFunction, ScalarGridFunctionConstruction)

Verifies scalar grid function construction for MMG grid function by checking exact expected values.

TEST(Rodin_MMG_GridFunction, VectorGridFunctionConstruction)

Verifies vector grid function construction for MMG grid function by checking exact expected values.

TEST(Rodin_MMG_MMG5, ParameterSetters)

Verify that parameter setters return reference for chaining.

TEST(Rodin_MMG_MMG5, AdaptParameterSetters)

Verifies adapt parameter setters for MMG MMG 5 by checking exact expected values.

TEST(Rodin_MMG_MMG5, LevelSetDiscretizerParameterSetters)

Verifies level set discretizer parameter setters for MMG MMG 5 by checking exact expected values.

TEST(Rodin_MMG_Mesh, ScalePreservesTopology)

Verifies scale preserves topology for MMG mesh by checking exact expected values.

TEST(Rodin_MMG_Mesh, SetAttributeOnCells)

Verifies set attribute on cells for MMG mesh by checking exact expected values, true predicates.

TEST(Rodin_MMG_Mesh, VertexCoordinates)

Verifies vertex coordinates for MMG mesh by checking exact expected values.

TEST(Rodin_MMG_Mesh, ScaleAffectsCoordinates)

Verifies scale affects coordinates for MMG mesh.

TEST(Rodin_MMG_Mesh, ConnectivityCompute)

Verifies connectivity compute for MMG mesh by checking exact expected values, true predicates, mesh connectivity computation.

TEST(Rodin_MMG_Mesh, IdempotentSetCorner)

Verifies idempotent set corner for MMG mesh by checking exact expected values.

TEST(Rodin_MMG_Mesh, IdempotentSetRidge)

Verifies idempotent set ridge for MMG mesh by checking exact expected values.

TEST(Rodin_MMG_Mesh, MoveAssignmentClearsSource)

Verifies move assignment clears source for MMG mesh by checking exact expected values, false predicates, move semantics.

TEST(Rodin_MMG_Mesh, CopyPreservesMetadataAfterMutation)

Verifies copy preserves metadata after mutation for MMG mesh by checking exact expected values, copy semantics.

TEST(Rodin_MMG_Mesh, ParentMoveAssignmentClearsMMGMetadata)

Verifies parent move assignment clears MMG metadata for MMG mesh by checking exact expected values, move semantics.

TEST(Rodin_MMG_Mesh, IsSurface)

A 2D uniform grid on triangles is not a surface mesh.

TEST(Rodin_MMG_Mesh, GetArea)

Verifies get area for MMG mesh.

TEST(Rodin_MMG_GridFunction, ScalarZeroInitialization)

Verifies scalar zero initialization for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarProjectFromLambda)

Verifies scalar project from lambda for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarProjectConstant)

Verifies scalar project constant for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarDataAccess)

Verifies scalar data access for MMG grid function by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_MMG_GridFunction, ScalarOperatorBracket)

Verifies scalar operator bracket for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarArithmeticAddScalar)

Verifies scalar arithmetic add scalar for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarArithmeticSubScalar)

Verifies scalar arithmetic sub scalar for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarArithmeticMulScalar)

Verifies scalar arithmetic mul scalar for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarArithmeticDivScalar)

Verifies scalar arithmetic div scalar for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarArithmeticAddGridFunction)

Verifies scalar arithmetic add grid function for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarArithmeticSubGridFunction)

Verifies scalar arithmetic sub grid function for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarArithmeticMulGridFunction)

Verifies scalar arithmetic mul grid function for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarArithmeticDivGridFunction)

Verifies scalar arithmetic div grid function for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarMinMax)

Verifies scalar min max for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarArgMinArgMax)

Verifies scalar arg min arg max for MMG grid function by checking exact expected values.

TEST(Rodin_MMG_GridFunction, ScalarCopyConstructor)

Verifies scalar copy constructor for MMG grid function by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_MMG_GridFunction, ScalarMoveConstructor)

Verifies scalar move constructor for MMG grid function by checking tolerance-based numerical results, exact expected values, move semantics.

TEST(Rodin_MMG_GridFunction, ScalarCopyAssignment)

Verifies scalar copy assignment for MMG grid function by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_MMG_GridFunction, ScalarFESAssociation)

Verifies scalar FES association for MMG grid function by checking exact expected values.

TEST(Rodin_MMG_GridFunction, ScalarPointEvaluation)

Verifies scalar point evaluation for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarLinearFunctionExactInterpolation)

Verifies scalar linear function exact interpolation for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, VectorProjectFromLambda)

Verifies vector project from lambda for MMG grid function by checking exact expected values.

TEST(Rodin_MMG_GridFunction, VectorFESAssociation)

Verifies vector FES association for MMG grid function by checking exact expected values.

TEST(Rodin_MMG_GridFunction, ScalarIOSaveLoadMEDIT)

Verifies scalar IO save load MEDIT for MMG grid function by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_MMG_GridFunction, ScalarIOSaveLoadMFEM)

Verifies scalar IO save load MFEM for MMG grid function by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_MMG_GridFunction, ScalarProjectThenAdapt)

Integration test: project a size map, adapt, then verify the adapted.

TEST(Rodin_MMG_GridFunction, VectorPointEvaluation)

Verifies vector point evaluation for MMG grid function by checking tolerance-based numerical results.

TEST(Rodin_MMG_GridFunction, ScalarSetData)

Verifies scalar set data for MMG grid function by checking tolerance-based numerical results.

TEST_P(LagrangianTest, BasicConstruction)

Test basic Lagrangian class construction.

TEST_P(LagrangianTest, DifferentVelocityFields)

Test Lagrangian with different velocity field types.

TEST_P(LagrangianTest, StepFunction)

Test Lagrangian step function basic functionality.

TEST_P(LagrangianTest, DifferentInitialConditions)

Test with different initial conditions.

INSTANTIATE_TEST_SUITE_P(LagrangianMeshParams, LagrangianTest, ::testing::Values(Polytope::Type::Quadrilateral, Polytope::Type::Triangle))

Instantiates Lagrangian Test over the Lagrangian Mesh Params parameter coverage.

TEST_F(FMMTest, SinglePointSource_2D_Triangle)

Verifies single point source 2 D triangle for FMM test by checking false predicates, solver behavior.

TEST_F(FMMTest, SurfaceMesh_Box_Triangle)

Verifies surface mesh box triangle for FMM test by checking exact expected values, false predicates, solver behavior.

TEST_F(FMMTest, VolumeMesh_3D_Tetrahedron)

Verifies volume mesh 3 D tetrahedron for FMM test by checking exact expected values, false predicates, solver behavior.

TEST_F(FMMTest, VariableSpeedFunction_2D)

Verifies variable speed function 2 D for FMM test by checking false predicates, solver behavior.

TEST_F(FMMTest, MultipleSources_2D)

Verifies multiple sources 2 D for FMM test by checking false predicates, solver behavior.

TEST_F(FMMTest, EmptyInterface)

Verifies empty interface for FMM test by checking true predicates, solver behavior.

TEST_F(FMMTest, BoundaryInterface_2D)

Verifies boundary interface 2 D for FMM test by checking false predicates, solver behavior.

TEST_F(FMMTest, InteriorRectangularInterface_2D)

Verifies interior rectangular interface 2 D for FMM test by checking tolerance-based numerical results, true predicates, false predicates.

TEST_F(FMMTest, LargeMeshStressTest_2D)

Verifies large mesh stress test 2 D for FMM test by checking false predicates, solver behavior.

TEST_F(FMMTest, MultipleDisconnectedInterfaces_2D)

Verifies multiple disconnected interfaces 2 D for FMM test by checking false predicates, solver behavior.

TEST(Rodin_Solid_KinematicState, Identity)

Verifies identity for solid kinematic state by checking tolerance-based numerical results.

TEST(Rodin_Solid_KinematicState, SimpleShear2D)

Verifies simple shear 2 D for solid kinematic state by checking tolerance-based numerical results.

TEST(Rodin_Solid_KinematicState, UniformExpansion3D)

Verifies uniform expansion 3 D for solid kinematic state by checking tolerance-based numerical results.

TEST(Rodin_Solid_KinematicState, InverseConsistency)

Verifies inverse consistency for solid kinematic state by checking tolerance-based numerical results.

TEST(Rodin_Solid_IsotropicInvariants, Identity)

Verifies identity for solid isotropic invariants by checking tolerance-based numerical results.

TEST(Rodin_Solid_IsotropicInvariants, Identity3D)

Verifies identity 3 D for solid isotropic invariants by checking tolerance-based numerical results.

TEST(Rodin_Solid_FiberInvariants, AlignedFiber)

Verifies aligned fiber for solid fiber invariants by checking tolerance-based numerical results.

TEST(Rodin_Solid_FiberKinematics, NormalizedDirectionAndStrain)

Verifies normalized direction and strain for solid fiber kinematics by checking tolerance-based numerical results.

TEST(Rodin_Solid_NeoHookean, ZeroDeformation)

Verifies zero deformation for solid neo hookean by checking tolerance-based numerical results.

TEST(Rodin_Solid_NeoHookean, StressSymmetryUnderPureStretch)

Verifies stress symmetry under pure stretch for solid neo hookean by checking tolerance-based numerical results.

TEST(Rodin_Solid_NeoHookean, TangentFiniteDifference)

Verifies tangent finite difference for solid neo hookean by checking tolerance-based numerical results.

TEST(Rodin_Solid_SaintVenantKirchhoff, ZeroDeformation)

Verifies zero deformation for solid saint venant kirchhoff by checking tolerance-based numerical results.

TEST(Rodin_Solid_SaintVenantKirchhoff, TangentFiniteDifference)

Verifies tangent finite difference for solid saint venant kirchhoff by checking tolerance-based numerical results.

TEST(Rodin_Solid_SaintVenantKirchhoff, ReducesToLinearElasticity)

For small deformations, SVK should behave like linear elasticity.

TEST(Rodin_Solid_MooneyRivlin, ZeroDeformation)

Verifies zero deformation for solid mooney rivlin by checking tolerance-based numerical results.

TEST(Rodin_Solid_MooneyRivlin, TangentFiniteDifference)

Verifies tangent finite difference for solid mooney rivlin by checking tolerance-based numerical results.

TEST(Rodin_Solid_HolzapfelOgden, ZeroDeformationStressFree)

Verifies zero deformation stress free for solid holzapfel ogden by checking tolerance-based numerical results.

TEST(Rodin_Solid_HolzapfelOgden, TangentFiniteDifference3D)

Verifies tangent finite difference 3 D for solid holzapfel ogden by checking tolerance-based numerical results.

TEST(Rodin_Solid_ActiveContraction, AddsFiberStress)

Verifies adds fiber stress for solid active contraction by checking tolerance-based numerical results.

TEST(Rodin_Solid_ActiveContraction, TangentFiniteDifference2D)

Pure active contribution: zero passive parameters so the FD check.

TEST(Rodin_Solid_ActiveContraction, TangentFiniteDifference3DWithPassive)

Mixed passive + active in 3D, fiber not aligned with an axis.

TEST(Rodin_Solid_ActiveContraction, DynamicTangentFiniteDifference2D)

Verifies that, after the per-quadrature-point local Newton on c.

TEST(Rodin_Solid_ActiveContraction, DynamicTangentFiniteDifference3DWithPassive)

Verifies dynamic tangent finite difference 3 D with passive for solid active contraction by checking tolerance-based numerical results, true predicates.

TEST(Rodin_Solid_ActiveContraction, DynamicLocalSolveResidualIsZero)

After the local Newton converges, the dynamic residual should be at.

TEST(Rodin_Solid_ActiveFiberLaw, StaticStressDerivativeFiniteDifference)

Verifies static stress derivative finite difference for solid active fiber law by checking tolerance-based numerical results.

TEST(Rodin_Solid_ActiveFiberLaw, InitialValues)

Verifies initial values for solid active fiber law by checking tolerance-based numerical results.

TEST(Rodin_Solid_Hooke, IsotropicStress)

Verifies isotropic stress for solid hooke by checking tolerance-based numerical results.

TEST(Rodin_Solid_Hooke, YoungPoissonConversion)

Verifies young poisson conversion for solid hooke by checking tolerance-based numerical results.

TEST(Rodin_Solid_GreenLagrangeStrain, ZeroDeformation)

Verifies zero deformation for solid green lagrange strain by checking tolerance-based numerical results.

TEST(Rodin_Solid_GreenLagrangeStrain, PureExtension)

Verifies pure extension for solid green lagrange strain by checking tolerance-based numerical results.

TEST(Rodin_Solid_CauchyStress, SymmetryCheck)

Verifies symmetry check for solid cauchy stress by checking tolerance-based numerical results.

TEST(Rodin_Solid_ConstitutivePoint, TypedTagSetGet)

Verifies typed tag set get for solid constitutive point by checking tolerance-based numerical results, true predicates, false predicates.

TEST(Rodin_Solid_ConstitutivePoint, ReferenceWrapperSemantics)

Verifies reference wrapper semantics for solid constitutive point by checking tolerance-based numerical results, false predicates.

TEST(Rodin_Solid_ConstitutivePoint, CustomTag)

Verifies custom tag for solid constitutive point by checking tolerance-based numerical results, true predicates.

TEST(Rodin_Solid_InternalVirtualWork_Residual, ZeroDisplacementZeroForce)

Verifies zero displacement zero force for solid internal virtual work residual by checking tolerance-based numerical results.

TEST(Rodin_Solid_InternalVirtualWork_Residual, ZeroDisplacementZeroForce_SVK)

Verifies zero displacement zero force SVK for solid internal virtual work residual by checking tolerance-based numerical results.

TEST(Rodin_Solid_InternalVirtualWork_Residual, ZeroDisplacementZeroForce_MooneyRivlin)

Verifies zero displacement zero force mooney rivlin for solid internal virtual work residual by checking tolerance-based numerical results.

TEST(Rodin_Solid_InternalVirtualWork_Residual, NonZeroDisplacementNonZeroForce)

Verifies non zero displacement non zero force for solid internal virtual work residual.

TEST(Rodin_Solid_InternalVirtualWork_Residual, WithInputFunction)

Verifies with input function for solid internal virtual work residual by checking true predicates.

TEST(Rodin_Solid_InternalVirtualWork_Tangent, ZeroDisplacementSymmetry)

Verifies zero displacement symmetry for solid internal virtual work tangent by checking tolerance-based numerical results.

TEST(Rodin_Solid_InternalVirtualWork_Tangent, ZeroDisplacementSymmetry_SVK)

Verifies zero displacement symmetry SVK for solid internal virtual work tangent by checking tolerance-based numerical results.

TEST(Rodin_Solid_InternalVirtualWork_Tangent, ZeroDisplacementSymmetry_MooneyRivlin)

Verifies zero displacement symmetry mooney rivlin for solid internal virtual work tangent by checking tolerance-based numerical results.

TEST(Rodin_Solid_InternalVirtualWork_Tangent, NonZeroDisplacementSymmetry)

Verifies non zero displacement symmetry for solid internal virtual work tangent by checking tolerance-based numerical results.

TEST(Rodin_Solid_InternalVirtualWork_Tangent, NonZeroDisplacementNonTrivial)

Verifies non zero displacement non trivial for solid internal virtual work tangent.

TEST(Rodin_Solid_InternalVirtualWork_Tangent, WithInputFunction)

Verifies with input function for solid internal virtual work tangent by checking true predicates.

TEST(Rodin_Solid_NeoHookean, TangentFiniteDifference3D)

Verifies tangent finite difference 3 D for solid neo hookean by checking tolerance-based numerical results.

TEST(Rodin_Solid_SaintVenantKirchhoff, TangentFiniteDifference3D)

Verifies tangent finite difference 3 D for solid saint venant kirchhoff by checking tolerance-based numerical results.

TEST(Rodin_Solid_MooneyRivlin, TangentFiniteDifference3D)

Verifies tangent finite difference 3 D for solid mooney rivlin by checking tolerance-based numerical results.

TEST(Rodin_Solid_NeoHookean, EnergyPositiveUnderDeformation)

Verifies energy positive under deformation for solid neo hookean.

TEST(Rodin_Solid_SaintVenantKirchhoff, EnergyPositiveUnderDeformation)

Verifies energy positive under deformation for solid saint venant kirchhoff.

TEST(Rodin_Solid_MooneyRivlin, EnergyPositiveUnderDeformation)

Verifies energy positive under deformation for solid mooney rivlin.

TEST(Rodin_Solid_Hooke, BulkModulusConsistency)

For isotropic material: K = lambda + 2*mu/d (2D), K = lambda + 2*mu/3 (3D).

TEST(Rodin_Solid_CauchyStress, SymmetryWithSVK)

Verifies symmetry with SVK for solid cauchy stress by checking tolerance-based numerical results.

TEST(Rodin_Solid_CauchyStress, SymmetryWithMooneyRivlin)

Verifies symmetry with mooney rivlin for solid cauchy stress by checking tolerance-based numerical results.

TEST(Rodin_Solid_FirstPiolaKirchhoffStress, ConsistencyWithLaw)

Verifies consistency with law for solid first piola kirchhoff stress by checking tolerance-based numerical results.

TEST(Rodin_Solid_MooneyRivlin, ParameterAccessors)

Verifies parameter accessors for solid mooney rivlin by checking tolerance-based numerical results.

TEST(Rodin_Solid_NeoHookean, ParameterAccessors)

Verifies parameter accessors for solid neo hookean by checking tolerance-based numerical results.

TEST(Rodin_Solid_SaintVenantKirchhoff, ParameterAccessors)

Verifies parameter accessors for solid saint venant kirchhoff by checking tolerance-based numerical results.

TEST(Rodin_Solid_ConstitutivePoint, DeclaredTagRoundTrips)

Verifies a declared tag round-trips through the constitutive point.

TEST(Rodin_Solid_ConstitutivePoint, SetOverwrites)

Verifies setting a tag twice overwrites rather than duplicates.

TEST(Rodin_Solid_ConstitutivePoint, DistinctTagsOfSameTypeDoNotAlias)

Verifies distinct tags of the same value type do not alias.

TEST(Rodin_Solid_ConstitutivePoint, UnsetTagIsAbsent)

Verifies an unset tag reports absent, and a set tag does not make an unrelated tag appear present.

TEST(Rodin_Solid_ConstitutivePoint, UserDefinedTagRoundTrips)

Verifies the tag set is open: tags declared outside the library, including one whose value type no library tag uses, round-trip.

TEST(Rodin_Solid_ConstitutivePoint, ExceedingReservedTagsStillRoundTrips)

Boundary: ReservedTags is a capacity hint, not a limit. Setting more tags than are reserved must still round-trip; the storage reallocates.

TEST(Rodin_Solid_ConstitutivePoint, CopyCarriesTags)

Verifies a copied constitutive point carries its tags.

TEST(Rodin_Solid_ActiveContraction, MidpointStrainIsUsedForTheSeriesLaw)

Verifies the series law is evaluated at the midpoint fiber strain: supplying a previous strain must reproduce the active extension obtained by evaluating at the midpoint directly.

TEST(Rodin_Solid_ActiveContraction, MidpointStrainHalvesTheCondensedTangent)

Verifies the condensed tangent carries the 1/2 chain-rule factor when the midpoint strain is used, since d(e^{n+1/2})/d(e^{n+1}) = 1/2.

TEST(Rodin_Solid_ActiveContraction, OmittingPreviousFiberStrainFallsBackToCurrentStrain)

Regression: omitting Tags::PreviousFiberStrain must reproduce the pre-midpoint behaviour exactly – the series law falls back to the current strain and the tangent carries no 1/2 factor. Existing callers that never set the tag must be unaffected.

TEST(Rodin_Moveable, BasicMove)

Verifies basic move for moveable by checking exact expected values, true predicates, false predicates.

TEST(Rodin_Moveable, PolymorphicMove)

Verifies polymorphic move for moveable by checking exact expected values, true predicates, false predicates.

TEST(Rodin_Moveable, MoveWithResource)

Verifies move with resource for moveable by checking exact expected values, true predicates, false predicates.

TEST(Rodin_Moveable, MultipleMoves)

Verifies multiple moves for moveable by checking exact expected values, true predicates, move semantics.

TEST(Rodin_Moveable, NoExceptSpecification)

Verify that move() is declared as noexcept.

TEST(Rodin_Moveable, OwnershipTransfer)

Test that the caller assumes ownership responsibility.

TEST(Assembly_MPI_Iteration, TriangleMesh_HasCells)

MPIIteration over a Triangle mesh yields at least one cell.

TEST(Assembly_MPI_Iteration, QuadrilateralMesh_HasCells)

MPIIteration over a Quadrilateral mesh yields at least one cell.

TEST(Assembly_MPI_Iteration, GlobalCellCount_MatchesLocal_Triangle)

Global cell count equals the sum of local counts across all ranks.

TEST(Assembly_MPI_DirichletBC, ConstantBC_NonEmpty_Triangle)

MPI DirichletBC assembly yields at least one boundary DOF entry on a Triangle mesh with a constant boundary condition.

TEST(Assembly_MPI_DirichletBC, SingleRank_MatchesSequentialCount_Triangle)

MPI DirichletBC assembly: boundary DOF count is consistent with the sequential assembly on the same mesh for a 1-rank run.

TEST(Assembly_MPI_DirichletBC, ConstantBC_Values_AllEqualPrescribed_Triangle)

MPI DirichletBC assembly: boundary DOF values are correct for a constant boundary condition.

TEST(Assembly_MPI_Iteration, SegmentMesh_HasCells)

MPIIteration over a 1D Segment mesh yields at least one cell.

TEST(Assembly_MPI_Iteration, GlobalCellCount_MatchesLocal_Segment)

Global cell count for a 1D Segment mesh equals the expected value.

TEST(Assembly_MPI_Iteration, All3DMeshes_HaveCells)

MPIIteration over every supported 3D cell mesh yields cells.

TEST(Assembly_MPI_DirichletBC, ConstantBC_Segment)

MPI DirichletBC assembly on Segment (1D) mesh: at least one boundary DOF is found and its value matches the prescribed constant.

TEST(Assembly_MPI_DirichletBC, ConstantBC_NonEmpty_All3D)

MPI DirichletBC assembly on every 3D cell fixes boundary DOFs.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Triangle_EachRankHasCellsAndVertices)

Verifies distribute triangle each rank has cells and vertices for MPI geometry sharder by checking MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Triangle_GlobalCellCount)

Verifies distribute triangle global cell count for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Triangle_GlobalVertexOwnership)

Verifies distribute triangle global vertex ownership for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Triangle_IsLocalInvariant)

Verifies distribute triangle is local invariant for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Triangle_PolytopeMapConsistency)

Verifies distribute triangle polytope map consistency for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Triangle_OwnerMapConsistency)

Verifies distribute triangle owner map consistency for MPI geometry sharder by checking MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Triangle_DimensionConsistency)

Verifies distribute triangle dimension consistency for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Quadrilateral_GlobalCellCount)

Verifies distribute quadrilateral global cell count for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Segment_GlobalCellCount)

Verifies distribute segment global cell count for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Tetrahedron_GlobalCellCount)

Verifies distribute tetrahedron global cell count for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Tetrahedron_DimensionConsistency)

Verifies distribute tetrahedron dimension consistency for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Hexahedron_GlobalCellCount)

Verifies distribute hexahedron global cell count for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Pyramid_GlobalCellCount)

Verifies distribute pyramid global cell count for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Wedge_GlobalCellCount)

Verifies distribute wedge global cell count for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Mixed2D_GlobalCellCount)

Verifies distribute mixed 2 D global cell count for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Mixed2D_GlobalVertexOwnership)

Verifies distribute mixed 2 D global vertex ownership for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Sharder, Distribute_Mixed2D_IsLocalInvariant)

Verifies distribute mixed 2 D is local invariant for MPI geometry sharder by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, GetPolytopeCount_Cells)

Verifies that MPIMesh::getPolytopeCount(D) for cells equals the parent mesh cell count (using the MPIMesh API directly, not manual shard iteration).

TEST(Rodin_MPI_Geometry_Mesh, GetPolytopeCount_Vertices)

Verifies that MPIMesh::getPolytopeCount(0) for vertices equals the parent mesh vertex count.

TEST(Rodin_MPI_Geometry_Mesh, GetPolytopeCount_ByType)

Verifies that MPIMesh::getPolytopeCount(Polytope::Type) correctly counts cells by geometry type.

TEST(Rodin_MPI_Geometry_Mesh, IndexMapping_RoundTrip)

Verifies that getLocalIndex and getGlobalIndex are inverses of each other for all local polytopes.

TEST(Rodin_MPI_Geometry_Mesh, IndexMapping_MissingReturnsNullopt)

Verifies that getLocalIndex returns nullopt for a global index that is not present in the local shard.

TEST(Rodin_MPI_Geometry_Mesh, GetContext)

Verifies that MPIMesh::getContext() returns the construction context.

TEST(Rodin_MPI_Geometry_Mesh, LocalIterators)

Verifies that local cell and vertex iterators on MPIMesh work correctly and iterate over the expected number of entities.

TEST(Rodin_MPI_Geometry_Mesh, GetGeometry_Cells)

Verifies that MPIMesh::getGeometry() returns correct geometry types for local cells.

TEST(Rodin_MPI_Geometry_Mesh, GetVertexCoordinates)

Verifies that MPIMesh::getVertexCoordinates() returns valid coordinates for all local vertices.

TEST(Rodin_MPI_Geometry_Mesh, Tetrahedron3D_GlobalCellCount)

Verifies that a 3D Tetrahedron mesh distributes correctly via MPIMesh and getPolytopeCount returns the correct global count.

TEST(Rodin_MPI_Geometry_Mesh, Scale)

Verifies that MPIMesh::scale() modifies vertex coordinates by the given factor on each rank.

TEST(Rodin_MPI_Geometry_Mesh, Flush)

Verifies that MPIMesh::flush() does not crash and the mesh remains valid afterward.

TEST(Rodin_MPI_Geometry_Mesh, IsSubMesh)

Verifies that MPIMesh::isSubMesh() returns false.

TEST(Rodin_MPI_Geometry_Mesh, GetConnectivity)

Verifies that MPIMesh::getConnectivity() returns the shard's connectivity and that cell-to-vertex incidence is valid.

TEST(Rodin_MPI_Geometry_Mesh, GetSetAttribute)

Verifies that getAttribute returns valid attributes and setAttribute modifies them.

TEST(Rodin_MPI_Geometry_Mesh, SetVertexCoordinates)

Verifies that setVertexCoordinates modifies vertex coordinates and the change is reflected in getVertexCoordinates.

TEST(Rodin_MPI_Geometry_Mesh, GetArea_Triangle2D)

Verifies that MPIMesh::getArea() returns the correct total area for a distributed 2D triangle mesh, matching the parent mesh area.

TEST(Rodin_MPI_Geometry_Mesh, GetVolume_Tetrahedron3D)

Verifies that MPIMesh::getVolume() returns the correct total volume for a distributed 3D tetrahedron mesh.

TEST(Rodin_MPI_Geometry_Mesh, GetPolytopeTransformation)

Verifies that MPIMesh::getPolytopeTransformation() returns valid transformations for all local cells.

TEST(Rodin_MPI_Geometry_Mesh, GetCellByIndex)

Verifies that MPIMesh::getCell(localIdx) returns a valid polytope for each local cell index.

TEST(Rodin_MPI_Geometry_Mesh, GetVertexByIndex)

Verifies that MPIMesh::getVertex(localIdx) returns a valid polytope for each local vertex index.

TEST(Rodin_MPI_Geometry_Mesh, GetMeasure_MatchesGetArea)

Verifies that MPIMesh::getMeasure(D) returns the same value as getArea() for a 2D mesh.

TEST(Rodin_MPI_Geometry_Mesh, AsSubMesh_Throws)

Verifies as sub mesh throws for MPI geometry mesh by checking exception behavior, MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, GetQuadrature)

Verifies get quadrature for MPI geometry mesh by checking exact expected values, true predicates, MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, GetBoundary_FaceCount)

Verifies get boundary face count for MPI geometry mesh by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, IsBoundary_IsInterface)

Verifies is boundary is interface for MPI geometry mesh by checking false predicates, MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, GetPerimeter_Triangle2D)

Verifies get perimeter triangle 2 D for MPI geometry mesh by checking tolerance-based numerical results, MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, UniformGrid_Triangle)

Verifies uniform grid triangle for MPI geometry mesh by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, UniformGrid_Pyramid)

Verifies uniform grid pyramid for MPI geometry mesh by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, SaveLoad_RoundTrip)

Verifies save load round trip for MPI geometry mesh by checking exact expected values, MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, GetInterface_WithFaces)

Verifies get interface with faces for MPI geometry mesh by checking MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Edges2D_GlobalOwnershipCount)

Verifies that after reconcile(1) on a 2D triangle mesh, the global sum of owned edges equals the total edge count in the parent mesh.

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Edges2D_PolytopeMapBidirectional)

Verifies that after reconcile(1), the edge polytope map is bidirectional (left and right are inverses).

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Edges2D_StateExclusivity)

Verifies that after reconcile(1), each edge has exactly one state (Owned, Shared, or Ghost) — states are mutually exclusive.

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Edges2D_OwnerMapConsistency)

Verifies that after reconcile(1), the owner map for edges is consistent: ghost edges point to valid non-self ranks.

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Edges2D_NoDuplicateOwnership)

Verifies that after reconcile(1), no distributed edge ID is owned by multiple ranks — each edge has a unique global owner.

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Edges2D_HaloMapConsistency)

Verifies that after reconcile(1), the halo map for edges is consistent: halo entries reference owned entities and valid remote ranks.

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Edges2D_SingleRank_AllOwned)

Verifies that with a single MPI rank, reconcile(1) marks all edges as Owned (no ghosts since there are no neighbors).

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Faces3D_GlobalOwnershipCount)

Verifies that reconcile(2) on a 3D tetrahedron mesh produces correct global face ownership count.

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Quad2D_GlobalEdgeCount)

Verifies that reconcile(1) works for a 2D quadrilateral mesh, producing the correct global edge ownership count.

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Faces3D_StateExclusivity)

Verifies that reconcile(2) on a 3D tetrahedron mesh produces mutually exclusive states for every face entity (exactly one of Owned, Shared, or Ghost).

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Faces3D_PolytopeMapBidirectional)

Verifies that reconcile(2) on a 3D mesh produces a bidirectional polytope map for faces.

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Edges2D_Idempotent)

Verifies that calling reconcile(1) twice is idempotent: the distributed IDs and ownership state do not change on a second call.

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Edges2D_StrictRoundCapThrows)

Verifies that strict round caps are enforced for reconcile().

TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Edges2D_GlobalCheckPeriodPreservesState)

Verifies that throttled global checks preserve reconcile correctness.

TEST(Rodin_MPI_Geometry_Mesh, ReconcileOptions_Presets)

Verifies reconcile options presets for MPI geometry mesh by checking exact expected values, false predicates, MPI behavior.

TEST(Rodin_MPI_Geometry_Mesh, Shard_HDF5_SaveLoad_BaseTopologyRoundTrip)

Verifies that each rank's shard can be saved to HDF5 and reloaded with base mesh topology preserved.

TEST(Rodin_MPI_Geometry_Mesh, Shard_HDF5_FullWorkflow_Reconcile)

Full HDF5 shard workflow: distribute → save → reload → reconcile.

TEST(MPIP0gSpace, GetSize_IsOne_Triangle)

Scalar P0g has exactly 1 global DOF on all ranks.

TEST(MPIP0gSpace, VectorDimension_IsOne_Triangle)

Scalar P0g has vector dimension 1.

TEST(MPIP0gSpace, AllLocalCells_MapToGlobalDOF0_Triangle)

For scalar P0g every local cell maps to global DOF 0.

TEST(MPIP0gSpace, GetGlobalIndex_ConsistentWithGetDOFs_Triangle)

getGlobalIndex() is consistent with getDOFs() for scalar P0g.

TEST(MPIP0gSpace, OwnershipRange_Rank0OwnsAll_OthersEmpty_Triangle)

Ownership range on rank 0 covers DOF 0; all other ranks are empty.

TEST(MPIP0gSpace, SingleRank_MatchesSequentialSpace_Triangle)

For single-rank run, MPI P0g matches the sequential P0g space.

TEST(MPIP0gSpace, VectorP0g_GetSize_Is2_Triangle)

Vector P0g(mesh, 2) has exactly 2 global DOFs.

TEST(MPIP0gSpace, VectorP0g_AllLocalCells_MapToGlobalDOFs_Triangle)

Vector P0g: every local cell maps to global DOFs {0, 1, ..., vdim-1}.

TEST(MPIP0gSpace, VectorP0g_OwnershipRange_Rank0OwnsAll_Triangle)

Vector P0g ownership range: rank 0 owns [0, vdim), others empty.

TEST(MPIP0gSpace, GetSize_IsOne_All3D)

Scalar P0g works on every supported 3D cell mesh.

TEST(MPIP0Space, GetSize_EqualsGlobalCellCount_Triangle)

getSize() of the distributed P0 space equals the global cell count.

TEST(MPIP0Space, GetSize_EqualsGlobalCellCount_All3D)

getSize() of the distributed P0 space equals the global cell count for every supported 3D cell mesh.

TEST(MPIP0Space, AllLocalCells_HaveValidGlobalDOF_Triangle)

Every local cell (owned and ghost) has a valid global DOF index after construction.

TEST(MPIP0Space, OwnedDOFs_GloballyUnique_Triangle)

Owned global DOF indices are unique across all ranks on a Triangle mesh.

TEST(MPIP0Space, OwnershipRange_Contiguous_Triangle)

getOwnershipRange returns a contiguous range consistent with the number of owned cells.

TEST(MPIP0Space, GetDOFs_ConsistentWithGetGlobalIndex_Triangle)

getDOFs(D, i)[0] == getGlobalIndex({D, i}, 0) for all local cells.

TEST(MPIP0Space, SingleRank_MatchesSequentialSpace_Triangle)

For a single MPI rank the distributed P0 space matches the sequential P0 space: same global size and same DOF indices for all cells.

TEST(MPIP0Space, VectorDimension_IsOne_Triangle)

Scalar P0 has vector dimension 1.

TEST(MPIP0Space, QuadrilateralMesh_GlobalSizeAndUniqueDOFs)

Distributed P0 on a Quadrilateral mesh: global size and unique DOFs.

TEST(MPISubMeshSparseSelection, EmptyRanks_ConstructP0P1H1_TriangleBoundary)

Verifies empty ranks construct P0 P1 H1 triangle boundary for MPI sub mesh sparse selection by checking exact expected values, MPI behavior.

TEST(MPISubMeshP0g, BoundarySubMesh_ScalarGlobalConstantDOFs_Triangle)

Verifies boundary sub mesh scalar global constant DO fs triangle for MPI sub mesh P0 g by checking exact expected values, MPI behavior.

TEST(MPISubMeshP0g, CellSubMesh_VectorGlobalConstantDOFs_Triangle)

Verifies cell sub mesh vector global constant DO fs triangle for MPI sub mesh P0 g by checking exact expected values, MPI behavior.

TEST(MPISubMeshP0g, SparseBoundarySubMesh_ConstructsOnEmptyRanks)

Verifies sparse boundary sub mesh constructs on empty ranks for MPI sub mesh P0 g by checking exact expected values, MPI behavior.

TEST(MPISubMeshH1, BoundarySubMesh_QuadraticH1_All3D)

Verifies boundary sub mesh quadratic H1 all 3 D for MPI sub mesh H1 by checking exact expected values, MPI behavior.

TEST(MPIP0FESSubMesh, BoundarySubMesh_GetSize_EqualsFaceCount_Triangle)

Scalar P0 FES on boundary SubMesh: global DOF count equals the number of boundary faces.

TEST(MPIP0FESSubMesh, BoundarySubMesh_VectorDimension_IsOne_Triangle)

Scalar P0 on boundary SubMesh has vector dimension 1.

TEST(MPIP0FESSubMesh, BoundarySubMesh_OwnershipRange_MatchesOwnedFaces_Triangle)

Ownership range of P0 on boundary SubMesh has width equal to the number of locally owned boundary faces.

TEST(MPIP0FESSubMesh, BoundarySubMesh_GetDOFs_ConsistentWithGetGlobalIndex_Triangle)

getDOFs and getGlobalIndex are consistent for P0 on boundary SubMesh.

TEST(MPIP0FESSubMesh, BoundarySubMesh_AllLocalFaces_HaveValidGlobalDOF_Triangle)

All local boundary faces have a valid global P0 DOF index.

TEST(MPIP0FESSubMesh, CellSubMesh_GetSize_EqualsParentCellCount_Triangle)

P0 FES on full-cell SubMesh: global DOF count equals the parent mesh global cell count (SubMesh covers the whole domain).

TEST(MPIP0FESSubMesh, CellSubMesh_OwnedDOFs_GloballyUnique_Triangle)

Owned P0 DOFs on the full-cell SubMesh are globally unique.

TEST(MPIP0FESSubMesh, BoundarySubMesh_GetSize_EqualsFaceCount_All3D)

P0 on boundary SubMesh of every 3D cell mesh: size equals face count.

TEST(MPIP1FESSubMesh, BoundarySubMesh_GetSize_EqualsVertexCount_Triangle)

Scalar P1 FES on boundary SubMesh: global DOF count equals the number of boundary vertices.

TEST(MPIP1FESSubMesh, BoundarySubMesh_OwnershipRange_MatchesOwnedVertices_Triangle)

Ownership range of P1 on boundary SubMesh has width equal to the number of locally owned boundary vertices.

TEST(MPIP1FESSubMesh, BoundarySubMesh_AllLocalVertices_HaveValidGlobalDOF_Triangle)

All local boundary vertices have a valid global P1 DOF index.

TEST(MPIP1FESSubMesh, CellSubMesh_GetSize_EqualsParentVertexCount_Triangle)

P1 FES on full-cell SubMesh: global DOF count equals the parent mesh global vertex count.

TEST(MPIP1FESSubMesh, CellSubMesh_OwnedDOFs_GloballyUnique_Triangle)

Owned P1 DOFs on the full-cell SubMesh are globally unique.

TEST(MPIP1FESSubMesh, BoundarySubMesh_OwnedDOFs_GloballyUnique_Triangle)

Owned P1 DOFs on boundary SubMesh are globally unique and cover the expected range exactly.

TEST(MPIP1FESSubMesh, Regression_P0CellThenP1Boundary_AllLocalVertices_HaveValidGlobalDOF)

Regression test for MPI message tag collision.

TEST(MPIP1FESSubMesh, Regression_P0CellThenP1Boundary_AllLocalVertices_HaveValidGlobalDOF_All3D)

Same regression test over all supported 3D cell meshes.

TEST(MPIP1FESSubMesh, Regression_OrphanVertex_AllLocalVertices_HaveValidGlobalDOF_Triangle)

Regression test for the SubMesh orphaned-vertex ownership bug.

TEST(Rodin_Pair, VariantConstructor)

Using deduction guide.

TEST(Rodin_Pair, Construction)

Verifies construction for pair by checking exact expected values.

TEST(Rodin_Pair, CopyConstruction)

Verifies copy construction for pair by checking exact expected values, copy semantics.

TEST(Rodin_Pair, MoveConstruction)

Verifies move construction for pair by checking exact expected values, move semantics.

TEST(Rodin_Pair, CopyAssignment)

Verifies copy assignment for pair by checking exact expected values, copy semantics.

TEST(Rodin_Pair, MoveAssignment)

Verifies move assignment for pair by checking exact expected values, move semantics.

TEST(Rodin_Pair, GetAccessors)

Verifies get accessors for pair by checking exact expected values.

TEST(Rodin_Pair, FirstSecondConst)

Verifies first second const for pair by checking exact expected values.

TEST(Rodin_Serialization_Mesh, to_stringstream)

Verifies to stringstream for serialization mesh by checking exact expected values, serialization round trips.

TEST(Rodin_Serialization_Mesh, ParametricTransformationRoundTrip)

Verifies polymorphic serialization of a parametric transformation.

TEST(Rodin_Tuple, VariantConstructor)

Verifies variant constructor for tuple by checking exact expected values.

TEST(Rodin_Tuple, CopyConstructor)

Verifies copy constructor for tuple by checking exact expected values, copy semantics.

TEST(Rodin_Tuple, CopyAssignment)

Verifies copy assignment for tuple by checking exact expected values, copy semantics.

TEST(Rodin_Tuple, MoveConstructor)

Verifies move constructor for tuple by checking exact expected values, move semantics.

TEST(Rodin_Tuple, MoveAssignment)

Verifies move assignment for tuple by checking exact expected values, move semantics.

TEST(Rodin_Tuple, ConcatenateNonEmpty)

Verifies concatenate non empty for tuple by checking exact expected values.

TEST(Rodin_Tuple, ConcatenateWithEmpty)

Verifies concatenate with empty for tuple by checking exact expected values.

TEST(Rodin_Tuple, ConcatenateChain)

Verifies concatenate chain for tuple by checking exact expected values.

TEST(Rodin_Tuple, ZipTwoTuples)

Verifies zip two tuples for tuple by checking exact expected values.

TEST(Rodin_Tuple, ZipMultipleTuples)

Verifies zip multiple tuples for tuple by checking exact expected values.

TEST(Rodin_Tuple, ZipCustomLambda)

Verifies zip custom lambda for tuple by checking exact expected values.

TEST(Rodin_Tuple, ReduceSum)

Verifies reduce sum for tuple by checking exact expected values.

TEST(Rodin_Tuple, ReduceProduct)

Verifies reduce product for tuple by checking exact expected values.

TEST(Rodin_Tuple, ReduceTwoElements)

Verifies reduce two elements for tuple by checking exact expected values.

TEST(Rodin_Tuple, MapTransform)

Verifies map transform for tuple by checking exact expected values.

TEST(Rodin_Tuple, MapTransformConst)

Verifies map transform const for tuple by checking exact expected values.

TEST(Rodin_Tuple, MapReturnDifferentType)

Verifies map return different type for tuple by checking exact expected values.

TEST(Rodin_Tuple, FilterIntegrals)

Mixed types: ints and doubles.

TEST(Rodin_Tuple, FilterAlwaysTrue)

Verifies filter always true for tuple by checking exact expected values.

TEST(Rodin_Tuple, FilterAlwaysFalse)

Verifies filter always false for tuple by checking exact expected values.

TEST(Rodin_Tuple, ApplyModification)

Verifies apply modification for tuple by checking exact expected values.

TEST(Rodin_Tuple, ApplyConst)

Verifies apply const for tuple by checking exact expected values.

TEST(Rodin_Tuple, IApplyWithIndex)

Verifies I apply with index for tuple by checking exact expected values.

TEST(Rodin_Tuple, ProductDefaultPairing)

Verifies product default pairing for tuple by checking exact expected values.

TEST(Rodin_Tuple, ProductCustomFunction)

Verifies product custom function for tuple by checking exact expected values.

TEST(Rodin_Tuple, ProductWithEmptyTuple)

Verifies product with empty tuple for tuple by checking exact expected values.

TEST(Rodin_Tuple, ProductNonSquare)

Verifies product non square for tuple by checking exact expected values.

TEST(Rodin_Tuple, GenerateIndexTuple)

Should create a tuple holding indices: 0, 1, 2, 3, 4.

TEST(Rodin_Tuple, GetConstAndNonConst)

Verifies get const and non const for tuple by checking exact expected values.

TEST(Rodin_Types, BasicTypes)

Test that basic types are defined and have expected properties.

TEST(Rodin_Types, TypeSizes)

Verify expected sizes for the types.

TEST(Rodin_Types, ComplexType)

Verifies complex type for types by checking tolerance-based numerical results.

TEST(Rodin_Types, ListType)

Verifies list type for types by checking exact expected values.

TEST(Rodin_Types, DequeType)

Verifies deque type for types by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Types, StackType)

Verifies stack type for types by checking exact expected values.

TEST(Rodin_Types, FlatSetType)

Verifies flat set type for types by checking exact expected values.

TEST(Rodin_Types, UnorderedSetType)

Verifies unordered set type for types by checking exact expected values, true predicates.

TEST(Rodin_Types, MapType)

Verifies map type for types by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Types, UnorderedMapType)

Verifies unordered map type for types by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Types, FlatMapType)

Verifies flat map type for types by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Types, IndexSetType)

Verifies index set type for types by checking exact expected values.

TEST(Rodin_Types, IndexMapType)

Verifies index map type for types by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Types, BitSetTypes)

Verifies bit set types for types by checking true predicates, false predicates.

TEST(Rodin_Types, OptionalType)

Verifies optional type for types by checking tolerance-based numerical results, exact expected values, true predicates.

TEST(Rodin_Types, UserDefinedLiteral_UZ)

Test the _UZ suffix for size_t values.

TEST(Rodin_Types, TemplateInstantiation)

Test that template types can be instantiated with different types.

TEST(Rodin_Variational_Abs, RealFunction_PositiveValue)

Verifies real function positive value for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, RealFunction_NegativeValue)

Verifies real function negative value for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, RealFunction_ZeroValue)

Verifies real function zero value for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, RealFunction_LargePositiveValue)

Verifies real function large positive value for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, RealFunction_LargeNegativeValue)

Verifies real function large negative value for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, RealFunction_SmallPositiveValue)

Verifies real function small positive value for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, RealFunction_SmallNegativeValue)

Verifies real function small negative value for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, GridFunction_AbsoluteValue)

Verifies grid function absolute value for variational abs by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Abs, ChainedOperations)

Verifies chained operations for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, DoubleAbsoluteValue)

Verifies double absolute value for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, AbsoluteValueIdentity)

Verifies absolute value identity for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, TriangleInequality)

Verifies triangle inequality for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, AbsoluteValueOfProduct)

Verifies absolute value of product for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, FractionalValues)

Verifies fractional values for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, AbsoluteValueNonNegativity)

Verifies absolute value non negativity for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Abs, AbsoluteValueOfDifference)

Verifies absolute value of difference for variational abs by checking tolerance-based numerical results.

TEST(Rodin_Variational_Average, ConstantFunction_AverageEqualsConstant)

Average of a constant function across any face should equal the constant.

TEST(Rodin_Variational_Average, ConstantVectorFunction_AverageEqualsConstant)

Average of a constant vector function should equal the same vector.

TEST(Rodin_Variational_Average, GridFunction_ContinuousFunction_AverageEqualsValue)

Average of a continuous P1 grid function should equal the function value.

TEST(Rodin_Variational_Average, CopyConstruction)

Verifies copy construction for variational average by checking tolerance-based numerical results, true predicates, copy semantics.

TEST(Rodin_Variational_Average, MoveConstruction)

Verifies move construction for variational average by checking tolerance-based numerical results, true predicates, move semantics.

TEST(Rodin_Variational_Average, PolymorphicCopy)

Verifies polymorphic copy for variational average by checking tolerance-based numerical results, true predicates, copy semantics.

TEST(Rodin_Variational_Average, JumpAndAverage_Consistency)

For a constant function, Jump=0 and Average=constant.

TEST(Rodin_Variational_Real_P1_BilinearForm, SanityTest_Build)

Verifies sanity test build for variational real P1 bilinear form by checking exact expected values.

TEST(Rodin_Variational_Real_P1_BilinearForm, CopyConstructor)

Verifies copy constructor for variational real P1 bilinear form by checking exact expected values, copy semantics.

TEST(Rodin_Variational_Real_P1_BilinearForm, MoveConstructor)

Verifies move constructor for variational real P1 bilinear form by checking exact expected values, move semantics.

TEST(Rodin_Variational_Real_P1_BilinearForm, Assignment)

Verifies assignment for variational real P1 bilinear form by checking false predicates.

TEST(Rodin_Variational_Real_P1_BilinearForm, AdditionAssignment)

Verifies addition assignment for variational real P1 bilinear form by checking false predicates.

TEST(Rodin_Variational_Real_P1_BilinearForm, SubtractionAssignment)

Verifies subtraction assignment for variational real P1 bilinear form by checking false predicates.

TEST(Rodin_Variational_Real_P1_BilinearForm, AssembleAndGetOperator)

Verifies assemble and get operator for variational real P1 bilinear form by checking exact expected values, form assembly.

TEST(Rodin_Variational_Real_P1_BilinearForm, Copy)

Verifies copy for variational real P1 bilinear form by checking copy semantics.

TEST(Rodin_Variational_Vector_P1_BilinearForm, SanityTest_Build)

Verifies sanity test build for variational vector P1 bilinear form by checking exact expected values.

TEST(Rodin_Variational_Vector_P1_BilinearForm, ElasticityIntegrator)

Verifies elasticity integrator for variational vector P1 bilinear form by checking form assembly.

TEST(Rodin_Variational_Real_P1_BilinearForm, MassMatrix)

Verifies mass matrix for variational real P1 bilinear form by checking form assembly.

TEST(Rodin_Variational_BooleanFunction, TrueConstant_Construction)

Verifies true constant construction for variational boolean function by checking true predicates.

TEST(Rodin_Variational_BooleanFunction, FalseConstant_Construction)

Verifies false constant construction for variational boolean function by checking false predicates.

TEST(Rodin_Variational_BooleanFunction, CopyConstructor_True)

Verifies copy constructor true for variational boolean function by checking exact expected values, true predicates, copy semantics.

TEST(Rodin_Variational_BooleanFunction, CopyConstructor_False)

Verifies copy constructor false for variational boolean function by checking exact expected values, false predicates, copy semantics.

TEST(Rodin_Variational_BooleanFunction, MoveConstructor_True)

Verifies move constructor true for variational boolean function by checking exact expected values, true predicates, move semantics.

TEST(Rodin_Variational_BooleanFunction, MoveConstructor_False)

Verifies move constructor false for variational boolean function by checking exact expected values, false predicates, move semantics.

TEST(Rodin_Variational_BooleanFunction, Copy_True)

Verifies copy true for variational boolean function by checking exact expected values, true predicates, copy semantics.

TEST(Rodin_Variational_BooleanFunction, Copy_False)

Verifies copy false for variational boolean function by checking exact expected values, false predicates, copy semantics.

TEST(Rodin_Variational_BooleanFunction, ConstantValue_MultiplePoints)

Verifies constant value multiple points for variational boolean function by checking true predicates, false predicates.

TEST(Rodin_Variational_BooleanFunction, PolymorphicUsage)

Test that we can use BooleanFunction polymorphically as BooleanFunctionBase.

TEST(Rodin_Variational_BooleanFunction, TraceToBoundary)

Verifies trace to boundary for variational boolean function by checking true predicates.

TEST(Rodin_Variational_BooleanFunction, CTAD_True)

Test Class Template Argument Deduction.

TEST(Rodin_Variational_BooleanFunction, CTAD_False)

Test Class Template Argument Deduction.

TEST(Rodin_Variational_Component, VectorFunction_ComponentAccess)

Verifies vector function component access for variational component by checking tolerance-based numerical results.

TEST(Rodin_Variational_Component, VectorShapeFunction_ComponentAccess)

Verifies vector shape function component access for variational component.

TEST(Rodin_Variational_Component, Copy)

Verifies copy for variational component by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_Variational_Component, CopyConstructor)

Verifies copy constructor for variational component by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_Variational_Component, MoveConstructor)

Verifies move constructor for variational component by checking tolerance-based numerical results, move semantics.

TEST(Rodin_Variational_Component, GetOperand)

Verifies get operand for variational component by checking tolerance-based numerical results.

TEST(Rodin_Variational_Component, UsageInLinearForm)

Verifies usage in linear form for variational component by checking form assembly.

TEST(Rodin_Variational_Component, UsageInBilinearForm)

Verifies usage in bilinear form for variational component by checking form assembly.

TEST(Rodin_Variational_Component, ZeroComponent)

Verifies zero component for variational component by checking tolerance-based numerical results.

TEST(Rodin_Variational_Component, NegativeComponents)

Verifies negative components for variational component by checking tolerance-based numerical results.

TEST(Rodin_Variational_Component, LargeVectorDimension)

Verifies large vector dimension for variational component by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, RealFunction_Zero)

Verifies real function zero for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, RealFunction_PiOverTwo)

Verifies real function pi over two for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, RealFunction_Pi)

Verifies real function pi for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, RealFunction_ThreePiOverTwo)

Verifies real function three pi over two for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, RealFunction_TwoPi)

Verifies real function two pi for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, RealFunction_PiOverSix)

Verifies real function pi over six for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, RealFunction_PiOverFour)

Verifies real function pi over four for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, RealFunction_PiOverThree)

Verifies real function pi over three for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, RealFunction_NegativeValue)

Verifies real function negative value for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, GridFunction_CosWave)

Verifies grid function cos wave for variational cos by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Cos, ChainedOperations)

Verifies chained operations for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, Periodicity)

Verifies periodicity for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, CosOfSum)

Verifies cos of sum for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, SmallAngle)

Verifies small angle for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, LargeAngle)

Verifies large angle for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, CosSquaredIdentity)

Verifies cos squared identity for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, CosWithMultiplication)

Verifies cos with multiplication for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, CosEvenFunction)

Verifies cos even function for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, SinCosIdentity)

Verifies sin cos identity for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, CosPhaseShift)

Verifies cos phase shift for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_Cos, CosPythagoreanIdentity)

Verifies cos pythagorean identity for variational cos by checking tolerance-based numerical results.

TEST(Rodin_Variational_DenseProblem, Construction)

Verifies construction for variational dense problem.

TEST(Rodin_Variational_DenseProblem, Assemble)

Verifies assemble for variational dense problem by checking exact expected values, form assembly.

TEST(Rodin_Variational_DenseProblem, StiffnessMatrixIsSymmetric)

Verifies stiffness matrix is symmetric for variational dense problem by checking tolerance-based numerical results, form assembly.

TEST(Rodin_Variational_DenseProblem, RHSIsNonZeroWithForcing)

Verifies RHS is non zero with forcing for variational dense problem by checking true predicates, form assembly.

TEST(Rodin_Variational_Real_P1_SanityTest, TriangularUniformGrid2)

Verifies triangular uniform grid 2 for variational real P1 sanity test by checking exact expected values, form assembly.

TEST(Rodin_Variational_Real_P1_SanityTest, TriangularUniformGrid16)

Verifies triangular uniform grid 16 for variational real P1 sanity test by checking exact expected values, form assembly.

TEST(Rodin_Variational_Real_P1_SanityTest, DirichletBCShapeFunctionIdentity)

Verifies dirichlet BC shape function identity for variational real P1 sanity test by checking tolerance-based numerical results, exact expected values, true predicates.

TEST(Rodin_Variational_Real_P1_SanityTest, DirichletBCShapeFunctionPointEvaluation)

Verifies dirichlet BC shape function point evaluation for variational real P1 sanity test by checking tolerance-based numerical results, exact expected values, true predicates.

TEST(Rodin_Variational_PointIntegrationPoint, H1MatchesBasis)

Verifies H1 matches basis for variational point integration point by checking tolerance-based numerical results.

TEST(Rodin_Variational_PointIntegrationPoint, H1GradMatchesBasisGradient)

Verifies H1 grad matches basis gradient for variational point integration point by checking tolerance-based numerical results.

TEST(Rodin_Variational_DirichletBC, ValueAPIAndBoundarySelection)

Verifies value API and boundary selection for variational dirichlet BC by checking tolerance-based numerical results, exact expected values, true predicates.

TEST(Rodin_Variational_DirichletBC, ValueFlatSetSelection)

Verifies value flat set selection for variational dirichlet BC by checking tolerance-based numerical results, exact expected values, true predicates.

TEST(Rodin_Variational_DirichletBC, IdentificationAPIAndScaledRows)

Verifies identification API and scaled rows for variational dirichlet BC by checking tolerance-based numerical results, exact expected values, true predicates.

TEST(Rodin_Variational_DirichletBC, IdentificationComponentSelection)

Verifies identification component selection for variational dirichlet BC by checking tolerance-based numerical results, exact expected values, true predicates.

TEST(Rodin_Variational_DirichletBC, IdentificationUnaryMinus)

Verifies that DirichletBC(u, -v) produces coefficient -1.

TEST(Rodin_Variational_DirichletBC, IdentificationScalarMultiplication)

DirichletBC(u, c*v) with constant scalar c produces coefficient c for the matching DOF.

TEST(Rodin_Variational_DirichletBC, IdentificationSelfDegenerate)

Self-identification DirichletBC(u, u).on(Γ) produces, for each slave DOF on Γ, the same DOF as master with coefficient 1 — a row which is algebraically vacuous (singular slave row) but assembled correctly.

TEST(Rodin_Variational_DirichletBC, IdentificationVectorVector)

Vector-to-vector identification: DirichletBC(u_vec, v_vec).

TEST(Rodin_Variational_DirichletBC, IdentificationDefaultBoundaryAllFaces)

When .on() is never called, the identification BC defaults to ALL boundary faces.

TEST(Rodin_Variational_DirichletBC, IdentificationOnTaggedInteriorFace)

Verifies identification on tagged interior face for variational dirichlet BC by checking tolerance-based numerical results, exact expected values, true predicates.

TEST(Rodin_Variational_DirichletBC, IdentificationGetValueReturnsShapeFunction)

getValue() returns a reference whose getUUID() matches v's UUID when the value is a plain shape function.

TEST(Rodin_Variational_DirichletBC, IsComponentAlwaysFalse)

Verify isComponent() returns false for both BC kinds — the Component<...> case is handled inside getBasis, not via the legacy isComponent() flag.

TEST(Rodin_Variational_DirichletBC, IdentificationSumOfShapeFunctions)

DirichletBC(u, A(v) + B(v)): the assembler should propagate pointwise basis evaluation through Sum and produce the sum of the two coefficient rows. For Lagrange same-FES with both summands being v itself, this collapses to coefficient 2 at the matching DOF.

TEST(Rodin_Variational_DirichletBC, AffineIdentificationStoresDefectValues)

DirichletBC(u, A(v), d) keeps the generic shape-function identification row for A(v) and stores the known defect through the slave FE's own DOF functional.

TEST(Rodin_Variational_DirichletBC, IdentificationReassemblesAfterOn)

Re-assembling after changing the boundary attribute set regenerates the IdentifiedDOFs map for the new region.

TEST(Rodin_Variational_ShapeFunctionSetPoint, H1MatchesBasis)

Verifies H1 matches basis for variational shape function set point by checking tolerance-based numerical results.

TEST(Rodin_Variational_ShapeFunctionSetPoint, H1GradMatchesBasisGradient)

Verifies H1 grad matches basis gradient for variational shape function set point by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, RealFunction_SimpleDivision)

Verifies real function simple division for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, RealFunction_DivisionByOne)

Verifies real function division by one for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, RealFunction_FractionalResult)

Verifies real function fractional result for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, RealFunction_LargeNumerator)

Verifies real function large numerator for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, RealFunction_SmallNumerator)

Verifies real function small numerator for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, RealFunction_NegativeValues)

Verifies real function negative values for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, RealFunction_BothNegative)

Verifies real function both negative for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, GridFunction_Division)

Verifies grid function division for variational division by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Division, ChainedDivision)

Verifies chained division for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, DivisionWithMultiplication)

Verifies division with multiplication for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, DivisionOfSum)

Verifies division of sum for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, ReciprocalProperty)

Verifies reciprocal property for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, DivisionByItself)

Verifies division by itself for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, LargeDivision)

Verifies large division for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, SmallDivision)

Verifies small division for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, DivisionWithSqrt)

Verifies division with sqrt for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, DivisionWithAbs)

Verifies division with abs for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, DistributiveProperty)

Verifies distributive property for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, DivisionOrder)

Verifies division order for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Division, FractionalDivision)

Verifies fractional division for variational division by checking tolerance-based numerical results.

TEST(Rodin_Variational_Div, VectorGridFunction_Construction)

Verifies vector grid function construction for variational div by checking exact expected values.

TEST(Rodin_Variational_Div, VectorShapeFunction_Construction)

Verifies vector shape function construction for variational div.

TEST(Rodin_Variational_Div, ConstantVectorField)

Verifies constant vector field for variational div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Div, LinearVectorField)

Verifies linear vector field for variational div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Div, Copy)

Verifies copy for variational div by checking copy semantics.

TEST(Rodin_Variational_Div, UsageInLinearForm)

Verifies usage in linear form for variational div by checking false predicates.

TEST(Rodin_Variational_Div, UsageInBilinearForm)

Verifies usage in bilinear form for variational div by checking form assembly.

TEST(Rodin_Variational_Div, 3D_VectorField)

Verifies 3 D vector field for variational div by checking grid-function projection.

TEST(Rodin_Variational_Div, ZeroVectorField)

Verifies zero vector field for variational div by checking tolerance-based numerical results.

TEST(Rodin_Variational_Div, MultipleEvaluations)

Verifies multiple evaluations for variational div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Div, GetOperand)

Verifies get operand for variational div by checking exact expected values.

TEST(Rodin_Variational_Div, CopyConstructor)

Verifies copy constructor for variational div by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_Variational_Div, MoveConstructor)

Verifies move constructor for variational div by checking tolerance-based numerical results, move semantics.

TEST(Rodin_Variational_Div, ShapeFunction_getDOFs_Triangle_P1)

Verifies shape function get DO fs triangle P1 for variational div by checking exact expected values.

TEST(Rodin_Variational_Div, ShapeFunction_getDOFs_Tetrahedron_P1)

Verifies shape function get DO fs tetrahedron P1 for variational div by checking exact expected values.

TEST(Rodin_Variational_Div, RandomCoordinates_LinearVectorField)

Verifies random coordinates linear vector field for variational div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Div, RandomCoordinates_DivergenceFreeField)

Verifies random coordinates divergence free field for variational div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Div, RandomCoordinates_Tetrahedron_LinearVectorField)

Verifies random coordinates tetrahedron linear vector field for variational div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Dot, VectorFunctions_Construction)

Verifies vector functions construction for variational dot.

TEST(Rodin_Variational_Dot, VectorFunctions_Value)

Verifies vector functions value for variational dot by checking tolerance-based numerical results.

TEST(Rodin_Variational_Dot, ShapeFunctions_Construction)

Verifies shape functions construction for variational dot.

TEST(Rodin_Variational_Dot, Gradients_Construction)

Verifies gradients construction for variational dot.

TEST(Rodin_Variational_Dot, Copy)

Verifies copy for variational dot by checking copy semantics.

TEST(Rodin_Variational_Dot, WithVectorFunctionAndShapeFunction)

Verifies with vector function and shape function for variational dot.

TEST(Rodin_Variational_Dot, InLinearForm)

Verifies in linear form for variational dot by checking form assembly.

TEST(Rodin_Variational_Dot, InBilinearForm)

Verifies in bilinear form for variational dot by checking form assembly.

TEST(Rodin_Variational_Dot, ZeroVectors)

Verifies zero vectors for variational dot by checking tolerance-based numerical results.

TEST(Rodin_Variational_Dot, OrthogonalVectors)

Verifies orthogonal vectors for variational dot by checking tolerance-based numerical results.

TEST(Rodin_Variational_Dot, ParallelVectors)

Verifies parallel vectors for variational dot by checking tolerance-based numerical results.

TEST(Rodin_Variational_Dot, 3D_Vectors)

Verifies 3 D vectors for variational dot by checking tolerance-based numerical results.

TEST(Rodin_Variational_Dot, CopyConstructor)

Verifies copy constructor for variational dot by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_Variational_Exp, RealFunction_Zero)

Verifies real function zero for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, RealFunction_One)

Verifies real function one for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, RealFunction_NegativeValue)

Verifies real function negative value for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, RealFunction_LargeValue)

Verifies real function large value for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, RealFunction_SmallValue)

Verifies real function small value for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, RealFunction_NaturalLog)

Verifies real function natural log for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, GridFunction_Exponential)

Verifies grid function exponential for variational exp by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Exp, ChainedOperations)

Verifies chained operations for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, ExponentialSum)

Verifies exponential sum for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, ExponentialProduct)

Verifies exponential product for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, ExponentialLaws)

Verifies exponential laws for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, ExponentialNegativeSum)

Verifies exponential negative sum for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, VerySmallValue)

Verifies very small value for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, ExponentialGrowth)

Verifies exponential growth for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, ExponentialWithSqrt)

Verifies exponential with sqrt for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, ExponentialPowers)

Verifies exponential powers for variational exp by checking tolerance-based numerical results.

TEST(Rodin_Variational_Exp, ExponentialMonotonicity)

Verifies exponential monotonicity for variational exp.

TEST(Rodin_Variational_Exp, ExponentialPositivity)

Verifies exponential positivity for variational exp.

TEST_P(FlowTest, BasicConstruction)

Test basic Flow class construction and coordinate handling.

TEST_P(FlowTest, VelocityFieldEvaluation)

Test different velocity field types and their evaluation.

TEST_P(FlowTest, MeshAccess)

Test mesh polytope access and validation.

INSTANTIATE_TEST_SUITE_P(FlowMeshParams, FlowTest, ::testing::Values(Polytope::Type::Quadrilateral, Polytope::Type::Triangle))

Instantiates Flow Test over the Flow Mesh Params parameter coverage.

TEST(Rodin_Variational_Grad, ShapeFunctionBasisValueCategories)

Verifies that basis forwarding preserves cached references and values.

TEST(Rodin_Variational_Grad, ShapeFunction_Construction)

Verifies shape function construction for variational grad.

TEST(Rodin_Variational_Grad, GridFunction_Construction)

Verifies grid function construction for variational grad by checking exact expected values.

TEST(Rodin_Variational_Grad, GridFunction_LinearFunction)

Verifies grid function linear function for variational grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Grad, GridFunction_ConstantFunction)

Verifies grid function constant function for variational grad by checking tolerance-based numerical results.

TEST(Rodin_Variational_Grad, Copy)

Verifies copy for variational grad by checking copy semantics.

TEST(Rodin_Variational_Grad, UsageInBilinearForm)

Verifies usage in bilinear form for variational grad by checking false predicates, form assembly.

TEST(Rodin_Variational_Grad, 3D_Mesh)

Test with 3D mesh (if supported by the current configuration).

TEST(Rodin_Variational_Grad, GridFunction_QuadraticFunction)

Verifies grid function quadratic function for variational grad by checking grid-function projection.

TEST(Rodin_Variational_Grad, MultipleEvaluations)

Verifies multiple evaluations for variational grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Grad, ShapeFunction_getDOFs_Triangle_P1)

Verifies shape function get DO fs triangle P1 for variational grad by checking exact expected values.

TEST(Rodin_Variational_Grad, ShapeFunction_getDOFs_Tetrahedron_P1)

Verifies shape function get DO fs tetrahedron P1 for variational grad by checking exact expected values.

TEST(Rodin_Variational_Grad, RandomCoordinates_LinearFunction)

Verifies random coordinates linear function for variational grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Grad, RandomCoordinates_ZeroGradient)

Verifies random coordinates zero gradient for variational grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Grad, RandomCoordinates_Tetrahedron_LinearFunction)

Verifies random coordinates tetrahedron linear function for variational grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_FiniteElementSpace, RangeTransformingPushforwardIsApplied)

Verifies that a nontrivial range pushforward is applied once to an expansion.

TEST(Rodin_Variational_Real_P1_GridFunction, SanityTest_Build)

Verifies sanity test build for variational real P1 grid function by checking exact expected values.

TEST(Rodin_Variational_Real_P1_GridFunction, AssignmentFromRealFunction)

Verifies assignment from real function for variational real P1 grid function by checking tolerance-based numerical results.

TEST(Rodin_Variational_Real_P1_GridFunction, ProjectLinearFunction)

Verifies project linear function for variational real P1 grid function by checking grid-function projection.

TEST(Rodin_Variational_Real_P1_GridFunction, ArithmeticOperations)

Verifies arithmetic operations for variational real P1 grid function by checking tolerance-based numerical results.

TEST(Rodin_Variational_Real_P1_GridFunction, SubtractionOperations)

Verifies subtraction operations for variational real P1 grid function by checking tolerance-based numerical results.

TEST(Rodin_Variational_Real_P1_GridFunction, DivisionOperations)

Verifies division operations for variational real P1 grid function by checking tolerance-based numerical results.

TEST(Rodin_Variational_Real_P1_GridFunction, MinMaxOperations)

Verifies min max operations for variational real P1 grid function by checking exact expected values.

TEST(Rodin_Variational_Vector_P1_GridFunction, SanityTest_Build)

Verifies sanity test build for variational vector P1 grid function by checking exact expected values.

TEST(Rodin_Variational_Vector_P1_GridFunction, ProjectVectorFunction)

Verifies project vector function for variational vector P1 grid function by checking grid-function projection.

TEST(Rodin_Variational_Vector_P1_GridFunction, EvaluateAtCellInterior)

Verifies vector P1 grid-function evaluation at an interior cell point.

TEST(Rodin_Variational_P1_GridFunction, EvaluationMatchesMappedBasisExpansion)

Verifies scalar and vector P1 evaluation against mapped-basis expansion.

TEST(Rodin_Variational_H1_GridFunction, CurvedP2EvaluationMatchesMappedBasisExpansion)

Verifies scalar and vector P2 evaluation on a curved cell.

TEST(Rodin_Variational_Real_P1_GridFunction, GetValue)

Verifies get value for variational real P1 grid function by checking tolerance-based numerical results.

TEST(Rodin_Variational_Real_P1_GridFunction, ZeroInitialization)

Verifies zero initialization for variational real P1 grid function by checking tolerance-based numerical results.

TEST(Rodin_Variational_H1_Derivative, GridFunction_Construction)

Verifies grid function construction for variational H1 derivative by checking exact expected values.

TEST(Rodin_Variational_H1_Derivative, GridFunction_ConstantFunction)

Verifies grid function constant function for variational H1 derivative by checking tolerance-based numerical results.

TEST(Rodin_Variational_H1_Derivative, GridFunction_LinearFunction)

Verifies grid function linear function for variational H1 derivative by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Derivative, GridFunction_QuadraticFunction)

Verifies grid function quadratic function for variational H1 derivative by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Derivative, GridFunction_Copy)

Verifies grid function copy for variational H1 derivative by checking exact expected values, copy semantics.

TEST(Rodin_Variational_H1_Derivative, GridFunction_GetOrder)

Verifies grid function get order for variational H1 derivative by checking exact expected values, true predicates.

TEST(Rodin_Variational_H1_Derivative, DxDyConsistentWithGrad)

Verifies dx dy consistent with grad for variational H1 derivative by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, ShapeFunction_Construction)

Verifies shape function construction for variational H1 div.

TEST(Rodin_Variational_H1_Div, GridFunction_Construction)

Verifies grid function construction for variational H1 div by checking exact expected values.

TEST(Rodin_Variational_H1_Div, GridFunction_ConstantVectorField)

Verifies grid function constant vector field for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, Copy)

Verifies copy for variational H1 div by checking copy semantics.

TEST(Rodin_Variational_H1_Div, GridFunction_LinearVectorField_H1_2)

Verifies grid function linear vector field H1 2 for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, GridFunction_DivergenceFreeField_H1_2)

Verifies grid function divergence free field H1 2 for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, GridFunction_QuadraticVectorField_H1_2)

Verifies grid function quadratic vector field H1 2 for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, GridFunction_QuadraticVectorField_H1_3)

Verifies grid function quadratic vector field H1 3 for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, MultipleRandomEvaluations)

Verifies multiple random evaluations for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, DifferentPolynomialDegrees)

Verifies different polynomial degrees for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, UsageInBilinearForm)

Verifies usage in bilinear form for variational H1 div by checking false predicates, form assembly.

TEST(Rodin_Variational_H1_Div, ZeroVectorField)

Verifies zero vector field for variational H1 div by checking tolerance-based numerical results.

TEST(Rodin_Variational_H1_Div, RandomCoordinatesOnMultipleCells)

Verifies random coordinates on multiple cells for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, RandomCoordinates_QuarticVectorField_H1_5)

Verifies random coordinates quartic vector field H1 5 for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, ProjectDivOntoGridFunction_LinearVectorField)

Verifies project div onto grid function linear vector field for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div, ProjectDivOntoGridFunction_QuadraticVectorField)

Verifies project div onto grid function quadratic vector field for variational H1 div by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div_Tet, ShapeFunction_Construction)

Verifies shape function construction for variational H1 div tet.

TEST(Rodin_Variational_H1_Div_Tet, GridFunction_Construction)

Verifies grid function construction for variational H1 div tet by checking exact expected values.

TEST(Rodin_Variational_H1_Div_Tet, GridFunction_ConstantFunction)

Verifies grid function constant function for variational H1 div tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div_Tet, GridFunction_LinearVectorField_H1_2)

Verifies grid function linear vector field H1 2 for variational H1 div tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div_Tet, GridFunction_QuadraticVectorField_H1_2)

Verifies grid function quadratic vector field H1 2 for variational H1 div tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div_Tet, RandomCoordinates_LinearVectorField)

Verifies random coordinates linear vector field for variational H1 div tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div_Quad, ShapeFunction_Construction)

Verifies shape function construction for variational H1 div quad.

TEST(Rodin_Variational_H1_Div_Quad, GridFunction_Construction)

Verifies grid function construction for variational H1 div quad by checking exact expected values.

TEST(Rodin_Variational_H1_Div_Quad, GridFunction_LinearVectorField_H1_2)

Verifies grid function linear vector field H1 2 for variational H1 div quad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Div_Quad, RandomCoordinates_LinearVectorField)

Verifies random coordinates linear vector field for variational H1 div quad by checking tolerance-based numerical results, grid-function projection.

TEST(DubinerTriangle, CollapsedCoords_Vertex_Origin)

(x,y) = (0,0) -> (r,s) = (-1,-1).

TEST(DubinerTriangle, CollapsedCoords_Vertex_X1)

(x,y) = (1,0) -> (r,s) = (1,-1).

TEST(DubinerTriangle, CollapsedCoords_Vertex_Y1)

(x,y) = (0,1) -> (r,s) = (-1, 1) (collapsed at top).

TEST(DubinerTriangle, CollapsedCoords_Center)

(x,y) = (1/3, 1/3) -> midpoint of triangle.

TEST(DubinerTriangle, Basis_P0Q0)

Ψ_{0,0} = P_0^{0,0}(a) * P_0^{1,0}(b) * 1 = 1 * 1 * 1 = 1.

TEST(DubinerTriangle, Basis_P1Q0)

Ψ_{1,0} involves P_1^{0,0}(a) = a.

TEST(DubinerTriangle, Basis_P0Q1)

Ψ_{0,1} involves P_0^{0,0}(a) * P_1^{1,0}(b).

TEST(DubinerTriangle, Gradient_P0Q0)

Verifies has zero reference gradient.

TEST(DubinerTriangle, Gradient_P1Q0_NoNaN)

Verifies gradient P1 Q 0 no na N for dubiner triangle by checking false predicates.

TEST(DubinerTriangle, Gradient_AtSingularity)

At s = 1 (top of triangle), there's a singularity.

TEST(VandermondeTriangle, MatrixSize_K1)

Verifies matrix size K 1 for vandermonde triangle by checking exact expected values.

TEST(VandermondeTriangle, MatrixSize_K2)

Verifies matrix size K 2 for vandermonde triangle by checking exact expected values.

TEST(VandermondeTriangle, MatrixSize_K5)

Verifies matrix size K 5 for vandermonde triangle by checking exact expected values.

TEST(VandermondeTriangle, InverseSize_K2)

Verifies inverse size K 2 for vandermonde triangle by checking exact expected values.

TEST(VandermondeTriangle, InverseIsInverse_K2)

Verifies inverse is inverse K 2 for vandermonde triangle by checking tolerance-based numerical results.

TEST(VandermondeTriangle, InverseIsInverse_K5)

Verifies inverse is inverse K 5 for vandermonde triangle by checking tolerance-based numerical results.

TEST(DubinerTetrahedron, CollapsedCoords_Vertex_Origin)

(x,y,z) = (0,0,0) -> (a,b,c) = (-1,-1,-1).

TEST(DubinerTetrahedron, CollapsedCoords_Vertex_X1)

(x,y,z) = (1,0,0) -> (a,b,c) = (1,-1,-1).

TEST(DubinerTetrahedron, CollapsedCoords_Vertex_Y1)

(x,y,z) = (0,1,0) -> (a,b,c).

TEST(DubinerTetrahedron, CollapsedCoords_Vertex_Z1)

(x,y,z) = (0,0,1) -> (a,b,c).

TEST(DubinerTetrahedron, Basis_P0Q0R0)

Ψ_{0,0,0} = 1.

TEST(DubinerTetrahedron, Basis_P1Q0R0_NoNaN)

Verifies basis P1 Q 0 R 0 no na N for dubiner tetrahedron by checking false predicates.

TEST(DubinerTetrahedron, Gradient_P0Q0R0)

Verifies has zero reference gradient.

TEST(DubinerTetrahedron, Gradient_P1Q0R0_NoNaN)

Verifies gradient P1 Q 0 R 0 no na N for dubiner tetrahedron by checking false predicates.

TEST(VandermondeTetrahedron, MatrixSize_K1)

Verifies matrix size K 1 for vandermonde tetrahedron by checking exact expected values.

TEST(VandermondeTetrahedron, MatrixSize_K2)

Verifies matrix size K 2 for vandermonde tetrahedron by checking exact expected values.

TEST(VandermondeTetrahedron, InverseSize_K2)

Verifies inverse size K 2 for vandermonde tetrahedron by checking exact expected values.

TEST(VandermondeTetrahedron, InverseIsInverse_K2)

Verifies inverse is inverse K 2 for vandermonde tetrahedron by checking tolerance-based numerical results.

TEST(DubinerTriangle, Basis_P2Q1_NoNaN)

Verifies basis P 2 Q 1 no na N for dubiner triangle by checking false predicates.

TEST(DubinerTriangle, Basis_P3Q2_NoNaN)

Verifies basis P 3 Q 2 no na N for dubiner triangle by checking false predicates.

TEST(DubinerTriangle, Gradient_P2Q1_NoNaN)

Verifies gradient P 2 Q 1 no na N for dubiner triangle by checking false predicates.

TEST(VandermondeTriangle, InverseIsInverse_K6)

Verifies inverse is inverse K 6 for vandermonde triangle by checking tolerance-based numerical results.

TEST(VandermondeTriangle, MatrixSize_K6)

Verifies matrix size K 6 for vandermonde triangle by checking exact expected values.

TEST(DubinerTetrahedron, Basis_P1Q1R0_NoNaN)

Verifies basis P1 Q 1 R 0 no na N for dubiner tetrahedron by checking false predicates.

TEST(DubinerTetrahedron, Basis_P2Q1R1_NoNaN)

Verifies basis P 2 Q 1 R 1 no na N for dubiner tetrahedron by checking false predicates.

TEST(DubinerTetrahedron, Gradient_P1Q1R0_NoNaN)

Verifies gradient P1 Q 1 R 0 no na N for dubiner tetrahedron by checking false predicates.

TEST(VandermondeTetrahedron, InverseIsInverse_K5)

Verifies inverse is inverse K 5 for vandermonde tetrahedron by checking tolerance-based numerical results.

TEST(VandermondeTetrahedron, MatrixSize_K5)

Verifies matrix size K 5 for vandermonde tetrahedron by checking exact expected values.

TEST(DubinerTriangle, Basis_P5Q5_K15_NoNaN)

Verifies basis P 5 Q 5 K 15 no na N for dubiner triangle by checking false predicates.

TEST(DubinerTriangle, Basis_P7Q3_K15_NoNaN)

Verifies basis P 7 Q 3 K 15 no na N for dubiner triangle by checking false predicates.

TEST(DubinerTriangle, Gradient_P5Q5_K15_NoNaN)

Verifies gradient P 5 Q 5 K 15 no na N for dubiner triangle by checking false predicates.

TEST(VandermondeTriangle, MatrixSize_K15)

Verifies matrix size K 15 for vandermonde triangle by checking exact expected values.

TEST(DubinerTetrahedron, Basis_P3Q3R3_K15_NoNaN)

Verifies basis P 3 Q 3 R 3 K 15 no na N for dubiner tetrahedron by checking false predicates.

TEST(DubinerTetrahedron, Basis_P5Q2R2_K15_NoNaN)

Verifies basis P 5 Q 2 R 2 K 15 no na N for dubiner tetrahedron by checking false predicates.

TEST(DubinerTetrahedron, Gradient_P3Q3R3_K15_NoNaN)

Verifies gradient P 3 Q 3 R 3 K 15 no na N for dubiner tetrahedron by checking false predicates.

TEST(VandermondeTetrahedron, MatrixSize_K15)

Verifies matrix size K 15 for vandermonde tetrahedron by checking exact expected values.

auto computeEdgeParameter2D(Real px, Real py, Real x0, Real y0, Real x1, Real y1) -> Real

Helper used by the tests to Compute Edge Parameter 2 D.

auto computeEdgeParameter3D(Real px, Real py, Real pz, Real x0, Real y0, Real z0, Real x1, Real y1, Real z1) -> Real

Helper used by the tests to Compute Edge Parameter 3 D.

template<size_t K>

auto extractSegmentNodes() -> std::vector<Real>

Helper used by the tests to Extract Segment Nodes.

template<size_t K>

auto extractTriangleEdgeNodes(Real x0, Real y0, Real x1, Real y1) -> std::vector<Real>

Helper used by the tests to Extract Triangle Edge Nodes.

template<size_t K>

auto extractQuadrilateralEdgeNodes(Real x0, Real y0, Real x1, Real y1) -> std::vector<Real>

Helper used by the tests to Extract Quadrilateral Edge Nodes.

template<size_t K>

auto extractTetrahedronEdgeNodes(Real x0, Real y0, Real z0, Real x1, Real y1, Real z1) -> std::vector<Real>

Helper used by the tests to Extract Tetrahedron Edge Nodes.

template<size_t K>

auto extractWedgeEdgeNodes(Real x0, Real y0, Real z0, Real x1, Real y1, Real z1) -> std::vector<Real>

Helper used by the tests to Extract Wedge Edge Nodes.

void compareEdgeCoordinates(const std::vector<Real>& edge1, const std::vector<Real>& edge2, const std::string& name1, const std::string& name2)

Helper used by the tests to Compare Edge Coordinates.

TEST(EdgeConformity, Segment_MatchesGLL01_K2)

Verifies segment matches GLL 01 K 2 for edge conformity by checking tolerance-based numerical results, exact expected values.

TEST(EdgeConformity, Segment_MatchesGLL01_K3)

Verifies segment matches GLL 01 K 3 for edge conformity by checking tolerance-based numerical results, exact expected values.

TEST(EdgeConformity, Segment_MatchesGLL01_K5)

Verifies segment matches GLL 01 K 5 for edge conformity by checking tolerance-based numerical results, exact expected values.

TEST(EdgeConformity, Triangle_Edge01_MatchesGLL01_K2)

Edge from (0,0) to (1,0).

TEST(EdgeConformity, Triangle_Edge02_MatchesGLL01_K2)

Edge from (0,0) to (0,1).

TEST(EdgeConformity, Triangle_Edge12_MatchesGLL01_K2)

Edge from (1,0) to (0,1).

TEST(EdgeConformity, Triangle_AllEdges_MatchGLL01_K3)

Verifies triangle all edges match GLL 01 K 3 for edge conformity.

TEST(EdgeConformity, Triangle_AllEdges_MatchGLL01_K5)

Verifies triangle all edges match GLL 01 K 5 for edge conformity.

TEST(EdgeConformity, Quadrilateral_AllEdges_MatchGLL01_K2)

Verifies quadrilateral all edges match GLL 01 K 2 for edge conformity.

TEST(EdgeConformity, Quadrilateral_AllEdges_MatchGLL01_K4)

Verifies quadrilateral all edges match GLL 01 K 4 for edge conformity.

TEST(EdgeConformity, Tetrahedron_AllEdges_MatchGLL01_K2)

Verifies tetrahedron all edges match GLL 01 K 2 for edge conformity.

TEST(EdgeConformity, Tetrahedron_AllEdges_MatchGLL01_K4)

Verifies tetrahedron all edges match GLL 01 K 4 for edge conformity.

TEST(EdgeConformity, Wedge_VerticalEdges_MatchGLL01_K2)

Wedge: triangle at z=0 and z=1, reference triangle (0,0)-(1,0)-(0,1).

TEST(EdgeConformity, Wedge_TriangleEdges_MatchTriangle_K3)

Triangle edges on z=0 face should match the triangle Fekete edge nodes.

TEST(EdgeConformity, Triangle_Quadrilateral_SharedEdge_K3)

Both triangle and quadrilateral have edge from (0,0) to (1,0).

TEST(EdgeConformity, Triangle_Tetrahedron_SharedEdge_K3)

Triangle edge (0,0)-(1,0) should match tetrahedron edge (0,0,0)-(1,0,0).

TEST(EdgeConformity, Triangle_Wedge_SharedEdge_K4)

Triangle edge (0,0)-(1,0) should match wedge edge (0,0,0)-(1,0,0).

TEST(EdgeConformity, Segment_Quadrilateral_SharedEdge_K4)

Segment nodes should match quadrilateral bottom edge.

TEST(EdgeConformity, Segment_Wedge_VerticalEdge_K5)

Segment nodes should match wedge vertical edge.

TEST(EdgeConformity, AllGeometries_EdgeNodes_Match_K6)

Verifies all geometries edge nodes match K 6 for edge conformity.

TEST(EdgeConformity3D, Tetrahedron_Wedge_SharedEdge_K3)

Both tetrahedron and wedge share edge (0,0,0)-(1,0,0) along x-axis.

TEST(EdgeConformity3D, Tetrahedron_Wedge_SharedEdge_YAxis_K3)

Both tetrahedron and wedge share edge (0,0,0)-(0,1,0) along y-axis.

TEST(EdgeConformity3D, Tetrahedron_Wedge_DiagonalEdge_K3)

Both share the diagonal edge (1,0,0)-(0,1,0) on the xy-plane face.

TEST(EdgeConformity3D, Tetrahedron_Wedge_AllSharedEdges_K4)

Test all edges that can be shared between tetrahedron and wedge base face.

TEST(EdgeConformity3D, Tetrahedron_Wedge_HighOrder_K5)

High-order test for tetrahedron-wedge shared edges.

TEST(EdgeConformity3D, Tetrahedron_Wedge_HighOrder_K6)

All shared edges at K=6.

TEST(EdgeConformity3D2D, Triangle_Tetrahedron_AllSharedEdges_K3)

Triangle can be a face of tetrahedron - all 3 edges should match.

TEST(EdgeConformity3D2D, Triangle_Wedge_AllSharedEdges_K3)

Triangle can be top or bottom face of wedge - all 3 edges should match.

TEST(EdgeConformity3D2D, Quadrilateral_Wedge_QuadFaces_K3)

Wedge has 3 quadrilateral faces - edges on these should match quadrilateral edges.

TEST(EdgeConformity3D2D, Quadrilateral_Tetrahedron_NoSharedFace)

Quadrilateral cannot be a face of tetrahedron, but edges can still match.

TEST(EdgeConformity3D2D, Segment_Tetrahedron_SharedEdge_K4)

1D segment should match any tetrahedron edge when parameterized.

TEST(EdgeConformity3D2D, Segment_Wedge_AllEdgeTypes_K4)

Segment should match all edge types on wedge.

TEST(EdgeConformity3D2D, AllGeometries_HighOrder_K5)

Comprehensive test: all geometry combinations at K=5.

TEST(EdgeConformity3D2D, AllGeometries_HighOrder_K6)

Comprehensive test: all geometry combinations at K=6.

TEST(EdgeConformity3D2D, AllGeometries_HighOrder_K15)

Comprehensive test: all geometry combinations at K=15.

TEST(EdgeConformity, AllGeometries_EdgeNodes_Match_K15)

Verifies all geometries edge nodes match K 15 for edge conformity.

TEST(EdgeConformity3D, Tetrahedron_Wedge_AllSharedEdges_K15)

Test all edges that can be shared between tetrahedron and wedge base face.

TEST(EdgeConformity, EdgeNodeCount_K15)

Segment should have K+1 = 16 nodes at K=15.

auto computeTriangleFaceBarycentric(Real px, Real py, Real pz, Real x0, Real y0, Real z0, Real x1, Real y1, Real z1, Real x2, Real y2, Real z2) -> std::tuple<Real, Real, Real>

Checks if a 3D point lies on a triangular face and computes its barycentric coordinates.

auto computeQuadFaceParametric(Real px, Real py, Real pz, Real x0, Real y0, Real z0, Real x1, Real y1, Real z1, Real x2, Real y2, Real z2, Real x3, Real y3, Real z3) -> std::pair<Real, Real>

Checks if a 3D point lies on a planar quadrilateral face and computes parametric coords.

template<size_t K>

auto extractTetrahedronTriangleFaceNodes(Real x0, Real y0, Real z0, Real x1, Real y1, Real z1, Real x2, Real y2, Real z2) -> std::vector<std::pair<Real, Real>>

Helper used by the tests to Extract Tetrahedron Triangle Face Nodes.

template<size_t K>

auto extractWedgeTriangleFaceNodes(Real x0, Real y0, Real z0, Real x1, Real y1, Real z1, Real x2, Real y2, Real z2) -> std::vector<std::pair<Real, Real>>

Helper used by the tests to Extract Wedge Triangle Face Nodes.

template<size_t K>

auto extractTriangleNodes() -> std::vector<std::pair<Real, Real>>

Helper used by the tests to Extract Triangle Nodes.

template<size_t K>

auto extractWedgeQuadFaceNodes(Real x0, Real y0, Real z0, Real x1, Real y1, Real z1, Real x2, Real y2, Real z2, Real x3, Real y3, Real z3) -> std::vector<std::pair<Real, Real>>

Helper used by the tests to Extract Wedge Quad Face Nodes.

template<size_t K>

auto extractQuadrilateralNodes() -> std::vector<std::pair<Real, Real>>

Helper used by the tests to Extract Quadrilateral Nodes.

void sortCoords2D(std::vector<std::pair<Real, Real>>& coords)

Helper used by the tests to Sort Coords 2 D.

void compareFaceCoordinates(std::vector<std::pair<Real, Real>> face1, std::vector<std::pair<Real, Real>> face2, const std::string& name1, const std::string& name2)

Helper used by the tests to Compare Face Coordinates.

TEST(FaceConformity, Tetrahedron_BaseFace_MatchesTriangle_K2)

Base face of tetrahedron (z=0 plane) should match reference triangle.

TEST(FaceConformity, Tetrahedron_BaseFace_MatchesTriangle_K3)

Verifies tetrahedron base face matches triangle K 3 for face conformity.

TEST(FaceConformity, Tetrahedron_BaseFace_MatchesTriangle_K4)

Verifies tetrahedron base face matches triangle K 4 for face conformity.

TEST(FaceConformity, Tetrahedron_BaseFace_MatchesTriangle_K5)

Verifies tetrahedron base face matches triangle K 5 for face conformity.

TEST(FaceConformity, Tetrahedron_BaseFace_MatchesTriangle_K6)

Verifies tetrahedron base face matches triangle K 6 for face conformity.

TEST(FaceConformity, Tetrahedron_Face013_MatchesTriangle_K3)

Face with vertices 0,1,3: (0,0,0), (1,0,0), (0,0,1) on y=0 plane.

TEST(FaceConformity, Tetrahedron_Face023_MatchesTriangle_K3)

Face with vertices 0,2,3: (0,0,0), (0,1,0), (0,0,1) on x=0 plane.

TEST(FaceConformity, Tetrahedron_Face123_MatchesTriangle_K3)

Face with vertices 1,2,3: (1,0,0), (0,1,0), (0,0,1) diagonal face.

TEST(FaceConformity, Wedge_BottomFace_MatchesTriangle_K2)

Bottom triangular face of wedge (z=0).

TEST(FaceConformity, Wedge_BottomFace_MatchesTriangle_K3)

Verifies wedge bottom face matches triangle K 3 for face conformity.

TEST(FaceConformity, Wedge_BottomFace_MatchesTriangle_K4)

Verifies wedge bottom face matches triangle K 4 for face conformity.

TEST(FaceConformity, Wedge_TopFace_MatchesTriangle_K3)

Top triangular face of wedge (z=1).

TEST(FaceConformity, Wedge_TopFace_MatchesTriangle_K4)

Verifies wedge top face matches triangle K 4 for face conformity.

TEST(FaceConformity, Tetrahedron_Wedge_TriangleFaces_Match_K2)

Both have triangular faces - they should have the same node distribution.

TEST(FaceConformity, Tetrahedron_Wedge_TriangleFaces_Match_K3)

Verifies tetrahedron wedge triangle faces match K 3 for face conformity.

TEST(FaceConformity, Tetrahedron_Wedge_TriangleFaces_Match_K4)

Verifies tetrahedron wedge triangle faces match K 4 for face conformity.

TEST(FaceConformity, Tetrahedron_Wedge_TriangleFaces_Match_K5)

Verifies tetrahedron wedge triangle faces match K 5 for face conformity.

TEST(FaceConformity, Tetrahedron_Wedge_TriangleFaces_Match_K6)

Verifies tetrahedron wedge triangle faces match K 6 for face conformity.

TEST(FaceConformity, Wedge_QuadFaceY0_MatchesQuadrilateral_K2)

Quad face at y=0.

TEST(FaceConformity, Wedge_QuadFaceY0_MatchesQuadrilateral_K3)

Verifies wedge quad face Y 0 matches quadrilateral K 3 for face conformity.

TEST(FaceConformity, Wedge_QuadFaceY0_MatchesQuadrilateral_K4)

Verifies wedge quad face Y 0 matches quadrilateral K 4 for face conformity.

TEST(FaceConformity, Wedge_QuadFaceX0_MatchesQuadrilateral_K3)

Quad face at x=0.

TEST(FaceConformity, Wedge_QuadFaceX0_MatchesQuadrilateral_K4)

Verifies wedge quad face X 0 matches quadrilateral K 4 for face conformity.

TEST(FaceConformity, WedgeTriangleFaces_Match_K5)

Reference triangle nodes.

TEST(FaceConformity, WedgeTriangleFaces_Match_K6)

Verifies wedge triangle faces match K 6 for face conformity.

TEST(FaceConformity, AllQuadFaces_Match_K5)

Verifies all quad faces match K 5 for face conformity.

TEST(FaceConformity, AllQuadFaces_Match_K6)

Verifies all quad faces match K 6 for face conformity.

TEST(FaceConformity, TriangleFaceNodeCount_K2)

Triangle should have (K+1)(K+2)/2 = 6 nodes at K=2.

TEST(FaceConformity, TriangleFaceNodeCount_K3)

Triangle should have (K+1)(K+2)/2 = 10 nodes at K=3.

TEST(FaceConformity, QuadFaceNodeCount_K2)

Quadrilateral should have (K+1)^2 = 9 nodes at K=2.

TEST(FaceConformity, QuadFaceNodeCount_K3)

Quadrilateral should have (K+1)^2 = 16 nodes at K=3.

TEST(FaceConformity, Tetrahedron_BaseFace_MatchesTriangle_K15)

Verifies tetrahedron base face matches triangle K 15 for face conformity.

TEST(FaceConformity, Tetrahedron_AllFaces_MatchTriangle_K15)

Verifies tetrahedron all faces match triangle K 15 for face conformity.

TEST(FaceConformity, Wedge_TriangleFaces_MatchTriangle_K15)

Verifies wedge triangle faces match triangle K 15 for face conformity.

TEST(FaceConformity, Tetrahedron_Wedge_TriangleFaces_Match_K15)

Verifies tetrahedron wedge triangle faces match K 15 for face conformity.

TEST(FaceConformity, Wedge_QuadFaces_MatchQuadrilateral_K15)

Verifies wedge quad faces match quadrilateral K 15 for face conformity.

TEST(FaceConformity, TriangleFaceNodeCount_K15)

Triangle should have (K+1)(K+2)/2 = 136 nodes at K=15.

TEST(FaceConformity, QuadFaceNodeCount_K15)

Quadrilateral should have (K+1)^2 = 256 nodes at K=15.

TEST(FeketeTriangle, NodeCount_K0)

(K+1)(K+2)/2 = (1)(2)/2 = 1.

TEST(FeketeTriangle, NodeCount_K1)

(K+1)(K+2)/2 = (2)(3)/2 = 3.

TEST(FeketeTriangle, NodeCount_K2)

(K+1)(K+2)/2 = (3)(4)/2 = 6.

TEST(FeketeTriangle, NodeCount_K3)

(K+1)(K+2)/2 = (4)(5)/2 = 10.

TEST(FeketeTriangle, NodeCount_K5)

(K+1)(K+2)/2 = (6)(7)/2 = 21.

TEST(FeketeTriangle, NodesInReferenceTriangle_K2)

All nodes should be in the reference triangle: x >= 0, y >= 0, x + y <= 1.

TEST(FeketeTriangle, NodesInReferenceTriangle_K5)

Verifies nodes in reference triangle K 5 for fekete triangle.

TEST(FeketeTriangle, NodesInReferenceTriangle_K10)

Verifies nodes in reference triangle K 10 for fekete triangle.

TEST(FeketeTriangle, ContainsVertices_K1)

K=1 should contain the three vertices.

TEST(FeketeTriangle, ContainsVertices_K5)

Verifies contains vertices K 5 for fekete triangle by checking true predicates.

TEST(FeketeTetrahedron, NodeCount_K0)

(K+1)(K+2)(K+3)/6 = (1)(2)(3)/6 = 1.

TEST(FeketeTetrahedron, NodeCount_K1)

(K+1)(K+2)(K+3)/6 = (2)(3)(4)/6 = 4.

TEST(FeketeTetrahedron, NodeCount_K2)

(K+1)(K+2)(K+3)/6 = (3)(4)(5)/6 = 10.

TEST(FeketeTetrahedron, NodeCount_K3)

(K+1)(K+2)(K+3)/6 = (4)(5)(6)/6 = 20.

TEST(FeketeTetrahedron, NodeCount_K5)

(K+1)(K+2)(K+3)/6 = (6)(7)(8)/6 = 56.

TEST(FeketeTetrahedron, NodesInReferenceTetrahedron_K2)

All nodes should be in the reference tetrahedron:.

TEST(FeketeTetrahedron, NodesInReferenceTetrahedron_K5)

Verifies nodes in reference tetrahedron K 5 for fekete tetrahedron.

TEST(FeketeTetrahedron, ContainsVertices_K1)

K=1 should contain the four vertices.

TEST(FeketeTetrahedron, ContainsVertices_K5)

Verifies contains vertices K 5 for fekete tetrahedron by checking true predicates.

TEST(FeketeTriangle, NodesAreUnique_K5)

Verifies nodes are unique K 5 for fekete triangle.

TEST(FeketeTetrahedron, NodesAreUnique_K3)

Verifies nodes are unique K 3 for fekete tetrahedron.

TEST(FeketeTriangle, NodeCount_K6)

(K+1)(K+2)/2 = (7)(8)/2 = 28.

TEST(FeketeTriangle, NodesInReferenceTriangle_K6)

Verifies nodes in reference triangle K 6 for fekete triangle.

TEST(FeketeTriangle, ContainsVertices_K6)

Verifies contains vertices K 6 for fekete triangle by checking true predicates.

TEST(FeketeTriangle, NodesAreUnique_K6)

Verifies nodes are unique K 6 for fekete triangle.

TEST(FeketeTetrahedron, NodeCount_K6)

(K+1)(K+2)(K+3)/6 = (7)(8)(9)/6 = 84.

TEST(FeketeTetrahedron, NodesInReferenceTetrahedron_K6)

Verifies nodes in reference tetrahedron K 6 for fekete tetrahedron.

TEST(FeketeTetrahedron, ContainsVertices_K6)

Verifies contains vertices K 6 for fekete tetrahedron by checking true predicates.

TEST(FeketeTetrahedron, NodesAreUnique_K5)

Verifies nodes are unique K 5 for fekete tetrahedron.

TEST(FeketeTriangle, NodeCount_K15)

(K+1)(K+2)/2 = (16)(17)/2 = 136.

TEST(FeketeTriangle, NodesInReferenceTriangle_K15)

Verifies nodes in reference triangle K 15 for fekete triangle.

TEST(FeketeTriangle, ContainsVertices_K15)

Verifies contains vertices K 15 for fekete triangle by checking true predicates.

TEST(FeketeTriangle, NodesAreUnique_K15)

Verifies nodes are unique K 15 for fekete triangle.

TEST(FeketeTetrahedron, NodeCount_K15)

(K+1)(K+2)(K+3)/6 = (16)(17)(18)/6 = 816.

TEST(FeketeTetrahedron, NodesInReferenceTetrahedron_K15)

Verifies nodes in reference tetrahedron K 15 for fekete tetrahedron.

TEST(FeketeTetrahedron, ContainsVertices_K15)

Verifies contains vertices K 15 for fekete tetrahedron by checking true predicates.

TEST(FeketeTetrahedron, NodesAreUnique_K15)

Verifies nodes are unique K 15 for fekete tetrahedron.

TEST(GLL, NodeCount_K0)

Verifies node count K 0 for GLL by checking exact expected values.

TEST(GLL, NodeCount_K1)

Verifies node count K 1 for GLL by checking exact expected values.

TEST(GLL, NodeCount_K2)

Verifies node count K 2 for GLL by checking exact expected values.

TEST(GLL, NodeCount_K5)

Verifies node count K 5 for GLL by checking exact expected values.

TEST(GLL, NodeCount_K10)

Verifies node count K 10 for GLL by checking exact expected values.

TEST(GLL, Endpoints_K1)

Verifies endpoints K 1 for GLL by checking tolerance-based numerical results.

TEST(GLL, Endpoints_K2)

Verifies endpoints K 2 for GLL by checking tolerance-based numerical results.

TEST(GLL, Endpoints_K5)

Verifies endpoints K 5 for GLL by checking tolerance-based numerical results.

TEST(GLL, Endpoints_K10)

Verifies endpoints K 10 for GLL by checking tolerance-based numerical results.

TEST(GLL, Ascending_K2)

Verifies ascending K 2 for GLL.

TEST(GLL, Ascending_K5)

Verifies ascending K 5 for GLL.

TEST(GLL, Ascending_K10)

Verifies ascending K 10 for GLL.

TEST(GLL, Symmetry_K2)

GLL nodes are symmetric about 0.

TEST(GLL, Symmetry_K3)

Verifies symmetry K 3 for GLL by checking tolerance-based numerical results.

TEST(GLL, Symmetry_K4)

Verifies symmetry K 4 for GLL by checking tolerance-based numerical results.

TEST(GLL, Symmetry_K5)

Verifies symmetry K 5 for GLL by checking tolerance-based numerical results.

TEST(GLL, KnownValues_K2)

K=2: nodes are -1, 0, 1.

TEST(GLL, KnownValues_K3)

K=3: nodes are -1, -1/sqrt(5), 1/sqrt(5), 1.

TEST(GLL, KnownValues_K4)

K=4: nodes are -1, -sqrt(3/7), 0, sqrt(3/7), 1.

TEST(GLL01, NodeCount)

Verifies node count for GLL 01 by checking exact expected values.

TEST(GLL01, Endpoints_K1)

Verifies endpoints K 1 for GLL 01 by checking tolerance-based numerical results.

TEST(GLL01, Endpoints_K2)

Verifies endpoints K 2 for GLL 01 by checking tolerance-based numerical results.

TEST(GLL01, Endpoints_K5)

Verifies endpoints K 5 for GLL 01 by checking tolerance-based numerical results.

TEST(GLL01, KnownValues_K2)

K=2 on [0,1]: 0, 0.5, 1.

TEST(GLL01, MappingConsistency)

GLL01 = (GLL + 1) / 2.

TEST(GLL01, Ascending_K5)

Verifies ascending K 5 for GLL 01.

TEST(GLL01, Range_K10)

All nodes should be in [0, 1].

TEST(GLL, InteriorNodesInInterval_K5)

All interior nodes should be in (-1, 1).

TEST(GLL, InteriorNodesInInterval_K10)

Verifies interior nodes in interval K 10 for GLL.

TEST(GLL, GetNode_K3)

Verifies get node K 3 for GLL by checking tolerance-based numerical results.

TEST(GLL01, GetNode_K3)

Verifies get node K 3 for GLL 01 by checking tolerance-based numerical results.

TEST(GLL, KnownValues_K5)

K=5: 6 nodes including -1 and 1.

TEST(GLL, Symmetry_K6)

Verifies symmetry K 6 for GLL by checking tolerance-based numerical results.

TEST(GLL, Ascending_K6)

Verifies ascending K 6 for GLL.

TEST(GLL, Endpoints_K6)

Verifies endpoints K 6 for GLL by checking tolerance-based numerical results.

TEST(GLL, InteriorNodesInInterval_K6)

Verifies interior nodes in interval K 6 for GLL.

TEST(GLL01, Endpoints_K6)

Verifies endpoints K 6 for GLL 01 by checking tolerance-based numerical results.

TEST(GLL01, MappingConsistency_K6)

GLL01 = (GLL + 1) / 2.

TEST(GLL01, Range_K6)

All nodes should be in [0, 1].

TEST(GLL, NodeCount_K6)

Verifies node count K 6 for GLL by checking exact expected values.

TEST(GLL01, NodeCount_K6)

Verifies node count K 6 for GLL 01 by checking exact expected values.

TEST(GLL, NodeCount_K15)

Verifies node count K 15 for GLL by checking exact expected values.

TEST(GLL, Endpoints_K15)

Verifies endpoints K 15 for GLL by checking tolerance-based numerical results.

TEST(GLL, Ascending_K15)

Verifies ascending K 15 for GLL.

TEST(GLL, Symmetry_K15)

Verifies symmetry K 15 for GLL by checking tolerance-based numerical results.

TEST(GLL, InteriorNodesInInterval_K15)

Verifies interior nodes in interval K 15 for GLL.

TEST(GLL01, NodeCount_K15)

Verifies node count K 15 for GLL 01 by checking exact expected values.

TEST(GLL01, Endpoints_K15)

Verifies endpoints K 15 for GLL 01 by checking tolerance-based numerical results.

TEST(GLL01, MappingConsistency_K15)

GLL01 = (GLL + 1) / 2.

TEST(GLL01, Range_K15)

All nodes should be in [0, 1].

TEST(GLL01, Ascending_K15)

Verifies ascending K 15 for GLL 01.

TEST(Rodin_Variational_H1_Grad, ShapeFunction_Construction)

Verifies shape function construction for variational H1 grad.

TEST(Rodin_Variational_H1_Grad, GridFunction_Construction)

Verifies grid function construction for variational H1 grad by checking exact expected values.

TEST(Rodin_Variational_H1_Grad, GridFunction_LinearFunction)

Verifies grid function linear function for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad, GridFunction_ConstantFunction)

Verifies grid function constant function for variational H1 grad by checking tolerance-based numerical results.

TEST(Rodin_Variational_H1_Grad, Copy)

Verifies copy for variational H1 grad by checking copy semantics.

TEST(Rodin_Variational_H1_Grad, UsageInBilinearForm)

Verifies usage in bilinear form for variational H1 grad by checking false predicates, form assembly.

TEST(Rodin_Variational_H1_Grad, GridFunction_QuadraticFunction_H1_2)

Verifies grid function quadratic function H1 2 for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad, GridFunction_QuadraticFunction_H1_3)

Verifies grid function quadratic function H1 3 for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad, MultipleEvaluations)

Verifies multiple evaluations for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad, DifferentPolynomialDegrees)

Verifies different polynomial degrees for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad_Tet, ShapeFunction_Construction)

Verifies shape function construction for variational H1 grad tet.

TEST(Rodin_Variational_H1_Grad_Tet, GridFunction_Construction)

Verifies grid function construction for variational H1 grad tet by checking exact expected values.

TEST(Rodin_Variational_H1_Grad_Tet, GridFunction_ConstantFunction)

Verifies grid function constant function for variational H1 grad tet by checking tolerance-based numerical results.

TEST(Rodin_Variational_H1_Grad_Tet, GridFunction_LinearFunction_H1_2)

Verifies grid function linear function H1 2 for variational H1 grad tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad_Tet, GridFunction_QuadraticFunction_H1_2)

Verifies grid function quadratic function H1 2 for variational H1 grad tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad_Tet, GridFunction_QuadraticFunction_H1_3)

Verifies grid function quadratic function H1 3 for variational H1 grad tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad_Tet, MultipleEvaluations)

Verifies multiple evaluations for variational H1 grad tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad_Tet, DifferentPolynomialDegrees)

Verifies different polynomial degrees for variational H1 grad tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad, RandomCoordinates_LinearFunction)

Verifies random coordinates linear function for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad, RandomCoordinates_QuadraticFunction)

Verifies random coordinates quadratic function for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad, RandomCoordinates_H1_3_QuadraticFunction)

Verifies random coordinates H1 3 quadratic function for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad, RandomCoordinates_ZeroGradient)

Verifies random coordinates zero gradient for variational H1 grad by checking tolerance-based numerical results.

TEST(Rodin_Variational_H1_Grad, RandomCoordinates_H1_5_QuarticFunction)

Verifies random coordinates H1 5 quartic function for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad, ProjectGradOntoGridFunction_LinearFunction)

Verifies project grad onto grid function linear function for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad, ProjectGradOntoGridFunction_QuadraticFunction)

Verifies project grad onto grid function quadratic function for variational H1 grad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad_Quad, ShapeFunction_Construction)

Verifies shape function construction for variational H1 grad quad.

TEST(Rodin_Variational_H1_Grad_Quad, GridFunction_Construction)

Verifies grid function construction for variational H1 grad quad by checking exact expected values.

TEST(Rodin_Variational_H1_Grad_Quad, GridFunction_LinearFunction)

Verifies grid function linear function for variational H1 grad quad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad_Quad, GridFunction_QuadraticFunction_H1_2)

Verifies grid function quadratic function H1 2 for variational H1 grad quad by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Grad_Quad, RandomCoordinates_QuadraticFunction)

Verifies random coordinates quadratic function for variational H1 grad quad by checking tolerance-based numerical results, grid-function projection.

TEST(H1Grad, ShapeFunction_getDOFs_Triangle_H1_2)

Verifies shape function get DO fs triangle H1 2 for H1 grad by checking exact expected values.

TEST(H1Grad, ShapeFunction_getDOFs_Tetrahedron_H1_2)

Verifies shape function get DO fs tetrahedron H1 2 for H1 grad by checking exact expected values.

TEST(Rodin_Variational_H1_Jacobian, ShapeFunction_Construction)

Verifies shape function construction for variational H1 jacobian.

TEST(Rodin_Variational_H1_Jacobian, GridFunction_Construction)

Verifies grid function construction for variational H1 jacobian by checking exact expected values.

TEST(Rodin_Variational_H1_Jacobian, GridFunction_ConstantFunction)

Verifies grid function constant function for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, Copy)

Verifies copy for variational H1 jacobian by checking copy semantics.

TEST(Rodin_Variational_H1_Jacobian, GridFunction_LinearVectorField_H1_2)

Verifies grid function linear vector field H1 2 for variational H1 jacobian by checking tolerance-based numerical results, exact expected values, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, GridFunction_QuadraticVectorField_H1_2)

Verifies grid function quadratic vector field H1 2 for variational H1 jacobian by checking tolerance-based numerical results, exact expected values, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, GridFunction_QuadraticVectorField_H1_3)

Verifies grid function quadratic vector field H1 3 for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, MultipleEvaluations)

Verifies multiple evaluations for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, DifferentPolynomialDegrees)

Verifies different polynomial degrees for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, UsageInBilinearForm)

Verifies usage in bilinear form for variational H1 jacobian by checking false predicates, form assembly.

TEST(Rodin_Variational_H1_Jacobian, RandomCoordinates_LinearVectorField)

Verifies random coordinates linear vector field for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, RandomCoordinates_QuadraticVectorField_H1_2)

Verifies random coordinates quadratic vector field H1 2 for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, RandomCoordinates_QuadraticVectorField_H1_3)

Verifies random coordinates quadratic vector field H1 3 for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, RandomCoordinates_ConstantVectorField)

Verifies random coordinates constant vector field for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, RandomCoordinates_QuarticVectorField_H1_5)

Verifies random coordinates quartic vector field H1 5 for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, ProjectJacobianOntoGridFunction_LinearVectorField)

Verifies project jacobian onto grid function linear vector field for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian, ProjectJacobianOntoGridFunction_QuadraticVectorField)

Verifies project jacobian onto grid function quadratic vector field for variational H1 jacobian by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian_Tet, ShapeFunction_Construction)

Verifies shape function construction for variational H1 jacobian tet.

TEST(Rodin_Variational_H1_Jacobian_Tet, GridFunction_Construction)

Verifies grid function construction for variational H1 jacobian tet by checking exact expected values.

TEST(Rodin_Variational_H1_Jacobian_Tet, GridFunction_ConstantFunction)

Verifies grid function constant function for variational H1 jacobian tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian_Tet, GridFunction_LinearVectorField_H1_2)

Verifies grid function linear vector field H1 2 for variational H1 jacobian tet by checking tolerance-based numerical results, exact expected values, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian_Tet, GridFunction_QuadraticVectorField_H1_2)

Verifies grid function quadratic vector field H1 2 for variational H1 jacobian tet by checking tolerance-based numerical results, exact expected values, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian_Tet, RandomCoordinates_LinearVectorField)

Verifies random coordinates linear vector field for variational H1 jacobian tet by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian_Quad, ShapeFunction_Construction)

Verifies shape function construction for variational H1 jacobian quad.

TEST(Rodin_Variational_H1_Jacobian_Quad, GridFunction_Construction)

Verifies grid function construction for variational H1 jacobian quad by checking exact expected values.

TEST(Rodin_Variational_H1_Jacobian_Quad, GridFunction_LinearVectorField_H1_2)

Verifies grid function linear vector field H1 2 for variational H1 jacobian quad by checking tolerance-based numerical results, exact expected values, grid-function projection.

TEST(Rodin_Variational_H1_Jacobian_Quad, RandomCoordinates_LinearVectorField)

Verifies random coordinates linear vector field for variational H1 jacobian quad by checking tolerance-based numerical results, grid-function projection.

TEST(JacobiPolynomial, P00_K0_IsLegendre)

P_0^{0,0}(x) = 1 (same as Legendre).

TEST(JacobiPolynomial, P00_K1_IsLegendre)

P_1^{0,0}(x) = x (same as Legendre).

TEST(JacobiPolynomial, P00_K2_IsLegendre)

P_2^{0,0}(x) = (3x^2 - 1)/2 (same as Legendre).

TEST(JacobiPolynomial, Derivative_K0)

Verifies for all tested and .

TEST(JacobiPolynomial, Derivative_K1_Alpha0_Beta0)

D/dx P_1^{0,0}(x) = 1.

TEST(JacobiPolynomial, Derivative_K2_Alpha0_Beta0)

D/dx P_2^{0,0}(x) = 3x (Legendre).

TEST(JacobiPolynomial, P10_K0)

P_0^{1,0}(x) = 1.

TEST(JacobiPolynomial, P10_K1)

Verifies .

TEST(JacobiPolynomial, P30_K0)

P_0^{3,0}(x) = 1.

TEST(JacobiPolynomial, P30_K1)

Verifies .

TEST(JacobiPolynomial, EndpointValue_x1)

Verifies the endpoint identity .

TEST(JacobiPolynomial, EndpointValue_xm1)

Verifies the endpoint identity .

TEST(JacobiPolynomial, DerivativeIdentity)

Verifies .

TEST(JacobiPolynomial, RecurrenceConsistency_K5)

Verify consistency at multiple points for K=5.

TEST(JacobiPolynomial, HigherAlpha_K2)

Test P_2^{5,0}(x) - used in Dubiner tetrahedron for (p,q,r) modes.

TEST(JacobiPolynomial, VeryHighAlpha_K3)

Test P_3^{10,0}(x) - verifying stability.

TEST(JacobiPolynomial, P00_K5_EndpointValues)

P_5^{0,0}(1) = 1, P_5^{0,0}(-1) = -1 (Legendre).

TEST(JacobiPolynomial, P00_K6_EndpointValues)

P_6^{0,0}(1) = 1, P_6^{0,0}(-1) = 1 (Legendre).

TEST(JacobiPolynomial, HigherAlpha_K5)

Test P_5^{7,0}(x) - used in high-order Dubiner tetrahedron.

TEST(JacobiPolynomial, HigherAlpha_K6)

Test P_6^{9,0}(x) - used in high-order Dubiner tetrahedron.

TEST(JacobiPolynomial, DerivativeIdentity_K5)

Verifies .

TEST(JacobiPolynomial, DerivativeIdentity_K6)

Verifies .

TEST(JacobiPolynomial, RecurrenceConsistency_K6)

Verify consistency at multiple points for K=6.

TEST(JacobiPolynomial, P00_K15_EndpointValues)

P_15^{0,0}(1) = 1, P_15^{0,0}(-1) = -1 (Legendre, odd degree).

TEST(JacobiPolynomial, P00_K15_AtZero)

P_15(0) = 0 for odd degree Legendre polynomial.

TEST(JacobiPolynomial, HigherAlpha_K15)

Test P_15^{10,0}(x) - used in high-order Dubiner tetrahedron.

TEST(JacobiPolynomial, VeryHighAlpha_K15)

Test P_15^{20,0}(x) - verifying stability for very high alpha.

TEST(JacobiPolynomial, RecurrenceConsistency_K15)

Verify consistency at multiple points for K=15.

TEST(JacobiPolynomial, DerivativeIdentity_K15)

Verifies .

TEST(LagrangeBasis1D, LagrangeProperty_K2)

On equispaced nodes [0, 0.5, 1].

TEST(LagrangeBasis1D, PartitionOfUnity_K2)

Verifies partition of unity K 2 for lagrange basis 1 D by checking tolerance-based numerical results.

TEST(LagrangeBasis1D, DerivativeSum_K2)

Sum of derivatives should be 0 (derivative of constant 1).

TEST(LagrangeBasisPoint, Basis_K0)

Verifies basis K 0 for lagrange basis point by checking tolerance-based numerical results.

TEST(LagrangeBasisPoint, Derivative_K0)

Verifies derivative K 0 for lagrange basis point by checking tolerance-based numerical results.

TEST(LagrangeBasisSegment, LagrangeProperty_K2)

GLL01<2> nodes are at 0, 0.5, 1.

TEST(LagrangeBasisSegment, LagrangeProperty_K3)

Verifies lagrange property K 3 for lagrange basis segment by checking tolerance-based numerical results.

TEST(LagrangeBasisSegment, PartitionOfUnity_K3)

Verifies partition of unity K 3 for lagrange basis segment by checking tolerance-based numerical results.

TEST(LagrangeBasisSegment, DerivativeSum_K3)

Verifies derivative sum K 3 for lagrange basis segment by checking tolerance-based numerical results.

TEST(LagrangeBasisTriangle, LagrangeProperty_K1)

K=1 has 3 nodes: (0,0), (1,0), (0,1).

TEST(LagrangeBasisTriangle, PartitionOfUnity_K2)

Verifies partition of unity K 2 for lagrange basis triangle by checking tolerance-based numerical results.

TEST(LagrangeBasisTriangle, PartitionOfUnity_K3)

Verifies partition of unity K 3 for lagrange basis triangle by checking tolerance-based numerical results.

TEST(LagrangeBasisTriangle, DerivativeSum_K2)

Verifies derivative sum K 2 for lagrange basis triangle by checking tolerance-based numerical results.

TEST(LagrangeBasisTetrahedron, LagrangeProperty_K1)

K=1 has 4 nodes: (0,0,0), (1,0,0), (0,1,0), (0,0,1).

TEST(LagrangeBasisTetrahedron, PartitionOfUnity_K2)

Verifies partition of unity K 2 for lagrange basis tetrahedron by checking tolerance-based numerical results.

TEST(LagrangeBasisTetrahedron, DerivativeSum_K2)

Verifies derivative sum K 2 for lagrange basis tetrahedron by checking tolerance-based numerical results.

TEST(LagrangeBasisQuadrilateral, LagrangeProperty_K2)

Verifies lagrange property K 2 for lagrange basis quadrilateral by checking tolerance-based numerical results.

TEST(LagrangeBasisQuadrilateral, PartitionOfUnity_K3)

Verifies partition of unity K 3 for lagrange basis quadrilateral by checking tolerance-based numerical results.

TEST(LagrangeBasisQuadrilateral, DerivativeSum_K2)

Verifies derivative sum K 2 for lagrange basis quadrilateral by checking tolerance-based numerical results.

TEST(LagrangeBasisWedge, PartitionOfUnity_K2)

Verifies partition of unity K 2 for lagrange basis wedge by checking tolerance-based numerical results.

TEST(LagrangeBasisWedge, DerivativeSum_K2)

Verifies derivative sum K 2 for lagrange basis wedge by checking tolerance-based numerical results.

TEST(LagrangeBasis1D, LagrangeProperty_K5)

Verifies lagrange property K 5 for lagrange basis 1 D by checking tolerance-based numerical results.

TEST(LagrangeBasis1D, PartitionOfUnity_K6)

Verifies partition of unity K 6 for lagrange basis 1 D by checking tolerance-based numerical results.

TEST(LagrangeBasisSegment, LagrangeProperty_K5)

Verifies lagrange property K 5 for lagrange basis segment by checking tolerance-based numerical results.

TEST(LagrangeBasisSegment, PartitionOfUnity_K6)

Verifies partition of unity K 6 for lagrange basis segment by checking tolerance-based numerical results.

TEST(LagrangeBasisTriangle, PartitionOfUnity_K5)

Verifies partition of unity K 5 for lagrange basis triangle by checking tolerance-based numerical results.

TEST(LagrangeBasisTriangle, PartitionOfUnity_K6)

Verifies partition of unity K 6 for lagrange basis triangle by checking tolerance-based numerical results.

TEST(LagrangeBasisTetrahedron, PartitionOfUnity_K5)

Verifies partition of unity K 5 for lagrange basis tetrahedron by checking tolerance-based numerical results.

TEST(LagrangeBasisQuadrilateral, LagrangeProperty_K5)

Verifies lagrange property K 5 for lagrange basis quadrilateral by checking tolerance-based numerical results.

TEST(LagrangeBasisQuadrilateral, PartitionOfUnity_K6)

Verifies partition of unity K 6 for lagrange basis quadrilateral by checking tolerance-based numerical results.

TEST(LagrangeBasisWedge, PartitionOfUnity_K5)

Verifies partition of unity K 5 for lagrange basis wedge by checking tolerance-based numerical results.

TEST(LagrangeBasis1D, LagrangeProperty_K15)

Verifies lagrange property K 15 for lagrange basis 1 D by checking tolerance-based numerical results.

TEST(LagrangeBasis1D, PartitionOfUnity_K15)

Verifies partition of unity K 15 for lagrange basis 1 D by checking tolerance-based numerical results.

TEST(LagrangeBasisSegment, LagrangeProperty_K15)

Verifies lagrange property K 15 for lagrange basis segment by checking tolerance-based numerical results.

TEST(LagrangeBasisSegment, PartitionOfUnity_K15)

Verifies partition of unity K 15 for lagrange basis segment by checking tolerance-based numerical results.

TEST(LagrangeBasisTriangle, PartitionOfUnity_K15)

Verifies partition of unity K 15 for lagrange basis triangle by checking tolerance-based numerical results.

TEST(LagrangeBasisTetrahedron, PartitionOfUnity_K15)

Verifies partition of unity K 15 for lagrange basis tetrahedron by checking tolerance-based numerical results.

TEST(LagrangeBasisQuadrilateral, PartitionOfUnity_K15)

Verifies partition of unity K 15 for lagrange basis quadrilateral by checking tolerance-based numerical results.

TEST(LagrangeBasisWedge, PartitionOfUnity_K15)

Verifies partition of unity K 15 for lagrange basis wedge by checking tolerance-based numerical results.

TEST(LegendrePolynomial, P0_Value)

P_0(x) = 1 for all x.

TEST(LegendrePolynomial, P1_Value)

P_1(x) = x.

TEST(LegendrePolynomial, P2_Value)

P_2(x) = (3x^2 - 1) / 2.

TEST(LegendrePolynomial, P3_Value)

P_3(x) = (5x^3 - 3x) / 2.

TEST(LegendrePolynomial, P4_Value)

P_4(x) = (35x^4 - 30x^2 + 3) / 8.

TEST(LegendrePolynomial, P0_Derivative)

P'_0(x) = 0.

TEST(LegendrePolynomial, P1_Derivative)

P'_1(x) = 1.

TEST(LegendrePolynomial, P2_Derivative)

P'_2(x) = 3x.

TEST(LegendrePolynomial, P3_Derivative)

P'_3(x) = (15x^2 - 3) / 2.

TEST(LegendrePolynomial, EndpointValues_K0_to_K10)

P_K(1) = 1 for all K.

TEST(LegendrePolynomial, Orthogonality_P0_P1)

Verifies the orthogonality integral .

TEST(LegendrePolynomial, Orthogonality_P1_P2)

Verifies the orthogonality integral .

TEST(LegendrePolynomial, Symmetry_EvenDegree)

P_K(-x) = P_K(x) for even K.

TEST(LegendrePolynomial, Symmetry_OddDegree)

P_K(-x) = -P_K(x) for odd K.

TEST(LegendrePolynomial, P5_Value)

P_5(x) = (63x^5 - 70x^3 + 15x) / 8.

TEST(LegendrePolynomial, P6_Value)

P_6(x) = (231x^6 - 315x^4 + 105x^2 - 5) / 16.

TEST(LegendrePolynomial, P5_Derivative)

P'_5(x) = (315x^4 - 210x^2 + 15) / 8.

TEST(LegendrePolynomial, P6_Derivative)

P'_6(x) = (1386x^5 - 1260x^3 + 210x) / 16.

TEST(LegendrePolynomial, Orthogonality_P2_P5)

Verifies the orthogonality integral .

TEST(LegendrePolynomial, P15_EndpointValues)

P_15(1) = 1, P_15(-1) = -1 (odd degree).

TEST(LegendrePolynomial, P15_AtZero)

P_15(0) = 0 (odd polynomial).

TEST(LegendrePolynomial, P15_Symmetry_OddDegree)

P_15(-x) = -P_15(x) for odd K.

TEST(LegendrePolynomial, P15_Value_NoNaN)

Verify no NaN/Inf at various points.

TEST(LegendrePolynomial, P15_Derivative_NoNaN)

Verifies P 15 derivative no na N for legendre polynomial by checking false predicates.

TEST(LegendrePolynomial, Orthogonality_P5_P15)

Verifies the orthogonality integral .

TEST(WarpFactor1D, Zero_K0)

K=0 should give zero warp.

TEST(WarpFactor1D, Zero_K1)

K=1 should give zero warp (only endpoints).

TEST(WarpFactor1D, ZeroAtEndpoints_K3)

Warp should be zero at endpoints.

TEST(WarpFactor1D, NonZeroInterior_K3)

Warp should be non-zero at interior points for K > 1.

TEST(WarpFactor1D, Finite_K5)

Verifies finite K 5 for warp factor 1 D by checking false predicates.

TEST(TriangleBlend, AlphaValues)

Verify known alpha values from Hesthaven-Warburton.

TEST(TriangleBlend, AlphaPositive_HigherOrders)

For higher orders, alpha should be positive.

TEST(TetrahedronBlend, AlphaValues)

Verify known alpha values.

TEST(WarpShiftFace2D, ZeroAtVertex_K2)

At vertex L1 = 1 (other two are 0).

TEST(WarpShiftFace2D, ZeroForLowOrder)

K=1 should give zero warp.

TEST(WarpShiftFace2D, Finite_K5)

Verifies finite K 5 for warp shift face 2 D by checking false predicates.

TEST(WarpBlendTriangle, PreservesVertices_K3)

Verifies preserves vertices K 3 for warp blend triangle by checking true predicates.

TEST(WarpBlendTriangle, NodesStayInTriangle_K5)

Verifies nodes stay in triangle K 5 for warp blend triangle.

TEST(WarpBlendTriangle, NoEffect_K1)

Verifies no effect K 1 for warp blend triangle by checking tolerance-based numerical results.

TEST(WarpBlendTetrahedron, PreservesVertices_K3)

Verifies preserves vertices K 3 for warp blend tetrahedron by checking true predicates.

TEST(WarpBlendTetrahedron, NodesStayInTetrahedron_K4)

Verifies nodes stay in tetrahedron K 4 for warp blend tetrahedron.

TEST(WarpBlendTetrahedron, NoEffect_K1)

Verifies no effect K 1 for warp blend tetrahedron by checking tolerance-based numerical results.

TEST(WarpFactor1D, Finite_K6)

Verifies finite K 6 for warp factor 1 D by checking false predicates.

TEST(WarpFactor1D, ZeroAtEndpoints_K5)

Verifies zero at endpoints K 5 for warp factor 1 D by checking tolerance-based numerical results.

TEST(WarpFactor1D, ZeroAtEndpoints_K6)

Verifies zero at endpoints K 6 for warp factor 1 D by checking tolerance-based numerical results.

TEST(WarpBlendTriangle, NodesStayInTriangle_K6)

Verifies nodes stay in triangle K 6 for warp blend triangle.

TEST(WarpBlendTriangle, PreservesVertices_K6)

Verifies preserves vertices K 6 for warp blend triangle by checking true predicates.

TEST(WarpBlendTetrahedron, NodesStayInTetrahedron_K5)

Verifies nodes stay in tetrahedron K 5 for warp blend tetrahedron.

TEST(WarpBlendTetrahedron, PreservesVertices_K5)

Verifies preserves vertices K 5 for warp blend tetrahedron by checking true predicates.

TEST(WarpShiftFace2D, Finite_K6)

Verifies finite K 6 for warp shift face 2 D by checking false predicates.

TEST(WarpFactor1D, ZeroAtEndpoints_K15)

Verifies zero at endpoints K 15 for warp factor 1 D by checking tolerance-based numerical results.

TEST(WarpFactor1D, Finite_K15)

Verifies finite K 15 for warp factor 1 D by checking false predicates.

TEST(TriangleBlend, Alpha_K15)

For K=15, alpha should be positive.

TEST(TetrahedronBlend, Alpha_K15)

For K=15, alpha should be positive.

TEST(WarpShiftFace2D, Finite_K15)

Verifies finite K 15 for warp shift face 2 D by checking false predicates.

TEST(WarpBlendTriangle, NodesStayInTriangle_K15)

Verifies nodes stay in triangle K 15 for warp blend triangle.

TEST(WarpBlendTriangle, PreservesVertices_K15)

Verifies preserves vertices K 15 for warp blend triangle by checking true predicates.

TEST(WarpBlendTetrahedron, NodesStayInTetrahedron_K15)

Verifies nodes stay in tetrahedron K 15 for warp blend tetrahedron.

TEST(WarpBlendTetrahedron, PreservesVertices_K15)

Verifies preserves vertices K 15 for warp blend tetrahedron by checking true predicates.

TEST(Rodin_Variational_RealH1Element, LinearForm_Triangle_MustBeNodal)

Verifies linear form triangle must be nodal for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, SanityTest_P2_0D_Reference_Point)

Verifies sanity test P 2 0 D reference point for variational real H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealH1Element, SanityTest_P2_1D_Reference_Segment)

Verifies sanity test P 2 1 D reference segment for variational real H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P2_Segment)

Verifies partition of unity P 2 segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, DerivativeTest_P2_1D_Reference_Segment)

Verifies derivative test P 2 1 D reference segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, SanityTest_P2_2D_Reference_Triangle)

Verifies sanity test P 2 2 D reference triangle for variational real H1 element by checking exact expected values.

TEST(Rodin_Variational_RealH1Element, SanityTest_P2_2D_Reference_Quadrilateral)

Verifies sanity test P 2 2 D reference quadrilateral for variational real H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P2_Quadrilateral)

Verifies partition of unity P 2 quadrilateral for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, SanityTest_P3_1D_Reference_Segment)

Verifies sanity test P 3 1 D reference segment for variational real H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P3_Segment)

Verifies partition of unity P 3 segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, SanityTest_P2_3D_Reference_Tetrahedron)

Verifies sanity test P 2 3 D reference tetrahedron for variational real H1 element by checking exact expected values.

TEST(Rodin_Variational_RealH1Element, SanityTest_P2_3D_Reference_Wedge)

Verifies sanity test P 2 3 D reference wedge for variational real H1 element by checking exact expected values.

TEST(Rodin_Variational_RealH1Element, SanityTest_P4_1D_Reference_Segment)

Verifies sanity test P 4 1 D reference segment for variational real H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P4_Segment)

Verifies partition of unity P 4 segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, DerivativeTest_P4_1D_Reference_Segment)

Verifies derivative test P 4 1 D reference segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, SanityTest_P5_1D_Reference_Segment)

Verifies sanity test P 5 1 D reference segment for variational real H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P5_Segment)

Verifies partition of unity P 5 segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, SymmetryTest_P5_Segment)

Verifies symmetry test P 5 segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, SanityTest_P6_1D_Reference_Segment)

Verifies sanity test P 6 1 D reference segment for variational real H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P6_Segment)

Verifies partition of unity P 6 segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, DerivativeTest_P6_1D_Reference_Segment)

Verifies derivative test P 6 1 D reference segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, DOFCount_Consistency_Segment)

Test DOF formula: (k+1) for Segment.

TEST(Rodin_Variational_RealH1Element, SanityTest_HigherOrders_Quadrilateral)

Test DOF formula: (k+1)^2 for Quadrilateral.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P3_Quadrilateral)

Verifies partition of unity P 3 quadrilateral for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P4_Quadrilateral)

Verifies partition of unity P 4 quadrilateral for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, SanityTest_HigherOrders_Triangle)

Test DOF formula: (k+1)(k+2)/2 for Triangle.

TEST(Rodin_Variational_RealH1Element, SanityTest_HigherOrders_Tetrahedron)

Test DOF formula: (k+1)(k+2)(k+3)/6 for Tetrahedron.

TEST(Rodin_Variational_RealH1Element, LinearReproduction_P2_Segment)

Verifies linear reproduction P 2 segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, QuadraticReproduction_P3_Segment)

Verifies quadratic reproduction P 3 segment for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, GradientConsistency_P4_Segment)

Verifies gradient consistency P 4 segment for variational real H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealH1Element, BasisNonNegativity_P3_Segment)

Verifies basis non negativity P 3 segment for variational real H1 element.

TEST(Rodin_Variational_RealH1Element, OrderProperty_AllOrders)

Verifies order property all orders for variational real H1 element by checking exact expected values.

TEST(Rodin_Variational_RealH1Element, LagrangeProperty_P2_Triangle)

Verifies lagrange property P 2 triangle for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P2_Triangle)

Verifies partition of unity P 2 triangle for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, LagrangeProperty_P3_Triangle)

Verifies lagrange property P 3 triangle for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P3_Triangle)

Verifies partition of unity P 3 triangle for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P4_Triangle)

Verifies partition of unity P 4 triangle for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, DerivativeConsistency_P2_Triangle)

Verifies derivative consistency P 2 triangle for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, LinearReproduction_P2_Triangle)

Verifies linear reproduction P 2 triangle for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, LagrangeProperty_P2_Tetrahedron)

Verifies lagrange property P 2 tetrahedron for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P2_Tetrahedron)

Verifies partition of unity P 2 tetrahedron for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, LagrangeProperty_P3_Tetrahedron)

Verifies lagrange property P 3 tetrahedron for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P3_Tetrahedron)

Verifies partition of unity P 3 tetrahedron for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, DerivativeConsistency_P2_Tetrahedron)

Verifies derivative consistency P 2 tetrahedron for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, LagrangeProperty_P2_Wedge)

Verifies lagrange property P 2 wedge for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P2_Wedge)

Verifies partition of unity P 2 wedge for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, LagrangeProperty_P3_Wedge)

Verifies lagrange property P 3 wedge for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P3_Wedge)

Verifies partition of unity P 3 wedge for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, DerivativeConsistency_P2_Wedge)

Verifies derivative consistency P 2 wedge for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, SanityTest_P2_3D_Reference_Pyramid)

Verifies sanity test P 2 3 D reference pyramid for variational real H1 element by checking exact expected values.

TEST(Rodin_Variational_RealH1Element, LagrangeProperty_P2_Pyramid)

Verifies lagrange property P 2 pyramid for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, PartitionOfUnity_P2_Pyramid)

Verifies partition of unity P 2 pyramid for variational real H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealH1Element, DOFCount_HigherOrders_Triangle)

Verifies DOF count higher orders triangle for variational real H1 element by checking exact expected values.

TEST(Rodin_Variational_RealH1Element, DOFCount_HigherOrders_Tetrahedron)

Verifies DOF count higher orders tetrahedron for variational real H1 element by checking exact expected values.

TEST(Rodin_Variational_RealH1Element, DOFCount_HigherOrders_Wedge)

Wedge: (k+1) * (k+1)(k+2)/2.

TEST(Rodin_Variational_RealH1Element, DOFCount_HigherOrders_Pyramid)

Verifies DOF count higher orders pyramid for variational real H1 element by checking exact expected values.

TEST(Rodin_Variational_ComplexH1Element, SanityTest_P2_Segment)

Verifies sanity test P 2 segment for variational complex H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_ComplexH1Element, PartitionOfUnity_P3_Segment)

Verifies partition of unity P 3 segment for variational complex H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_ComplexH1Element, LagrangeProperty_P2_Triangle)

Verifies lagrange property P 2 triangle for variational complex H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_ComplexH1Element, PartitionOfUnity_P2_Quadrilateral)

Verifies partition of unity P 2 quadrilateral for variational complex H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_ComplexH1Element, DOFCount_Consistency)

Verifies DOF count consistency for variational complex H1 element by checking exact expected values.

TEST(Rodin_Variational_VectorH1Element, SanityTest_P2_Segment_2D)

Verifies sanity test P 2 segment 2 D for variational vector H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_VectorH1Element, SanityTest_P3_Segment_3D)

Verifies sanity test P 3 segment 3 D for variational vector H1 element by checking exact expected values.

TEST(Rodin_Variational_VectorH1Element, BasisStructure_P2_Segment)

Verifies basis structure P 2 segment for variational vector H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorH1Element, SanityTest_P2_Triangle_2D)

Verifies sanity test P 2 triangle 2 D for variational vector H1 element by checking exact expected values.

TEST(Rodin_Variational_VectorH1Element, SanityTest_P2_Quadrilateral_2D)

Verifies sanity test P 2 quadrilateral 2 D for variational vector H1 element by checking exact expected values.

TEST(Rodin_Variational_VectorH1Element, SanityTest_P2_Tetrahedron_3D)

Verifies sanity test P 2 tetrahedron 3 D for variational vector H1 element by checking exact expected values.

TEST(Rodin_Variational_VectorH1Element, JacobianTest_P2_Segment)

Verifies jacobian test P 2 segment for variational vector H1 element by checking exact expected values.

TEST(Rodin_Variational_VectorH1Element, DOFCount_Consistency)

Verifies DOF count consistency for variational vector H1 element by checking exact expected values.

TEST(Rodin_Variational_VectorH1Element, HigherOrder_P4_Segment)

Verifies higher order P 4 segment for variational vector H1 element by checking exact expected values.

TEST(Rodin_Variational_VectorH1Element, P3_Wedge_3D)

Verifies P 3 wedge 3 D for variational vector H1 element by checking exact expected values.

TEST(Rodin_Variational_ComplexH1Element, PartitionOfUnity_P4_Triangle)

Verifies partition of unity P 4 triangle for variational complex H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_ComplexH1Element, PartitionOfUnity_P5_Quadrilateral)

Verifies partition of unity P 5 quadrilateral for variational complex H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_ComplexH1Element, LagrangeProperty_P3_Tetrahedron)

Verifies lagrange property P 3 tetrahedron for variational complex H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_ComplexH1Element, DOFCount_HigherOrders)

Verifies DOF count higher orders for variational complex H1 element by checking exact expected values.

TEST(Rodin_Variational_ComplexH1Element, LinearReproduction_P2_Segment)

Verifies linear reproduction P 2 segment for variational complex H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_ComplexH1Element, BasisSymmetry_P3_Segment)

Verifies basis symmetry P 3 segment for variational complex H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorH1Element, PartitionOfUnity_P3_Triangle)

Verifies partition of unity P 3 triangle for variational vector H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorH1Element, LagrangeProperty_P2_Quadrilateral)

Verifies lagrange property P 2 quadrilateral for variational vector H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorH1Element, HigherOrder_P4_Tetrahedron)

Verifies higher order P 4 tetrahedron for variational vector H1 element by checking exact expected values.

TEST(Rodin_Variational_VectorH1Element, ComponentSparsity_P2_Segment)

Verifies component sparsity P 2 segment for variational vector H1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_VectorH1Element, GradientConsistency_P3_Segment)

Verifies gradient consistency P 3 segment for variational vector H1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorH1Element, DOFCount_AllGeometries_P5)

Verifies DOF count all geometries P 5 for variational vector H1 element by checking exact expected values.

TEST(Rodin_Variational_VectorH1Element, LinearReproduction_P2_Segment)

Verifies linear reproduction P 2 segment for variational vector H1 element by checking tolerance-based numerical results.

TEST(FinalTest_H1Element_Real, PartitionOfUnity_P2_AllGeometries)

Verifies partition of unity P 2 all geometries for final test H1 element real by checking tolerance-based numerical results.

TEST(FinalTest_H1Element_Real, PartitionOfUnity_P3_P4_P5_P6_Segment)

Verifies partition of unity P 3 P 4 P 5 P 6 segment for final test H1 element real by checking tolerance-based numerical results.

TEST(FinalTest_H1Element_Real, LagrangeProperty_P2_Segment)

Verifies lagrange property P 2 segment for final test H1 element real by checking tolerance-based numerical results.

TEST(FinalTest_H1Element_Real, LagrangeProperty_P3_P4_P5_P6_Segment)

Test orders 3-6.

TEST(FinalTest_H1Element_Real, QuadraticReproduction_P2_Segment)

Verifies quadratic reproduction P 2 segment for final test H1 element real by checking tolerance-based numerical results.

TEST(FinalTest_H1Element_Complex, PartitionOfUnity_P2_P3_P4_Segment)

Verifies partition of unity P 2 P 3 P 4 segment for final test H1 element complex by checking tolerance-based numerical results.

TEST(FinalTest_H1Element_Complex, ComplexQuadraticReproduction_P2_Segment)

Verifies complex quadratic reproduction P 2 segment for final test H1 element complex by checking tolerance-based numerical results.

TEST(FinalTest_H1Element_Vector, ComponentStructure_P2_2D_Segment)

Verifies component structure P 2 2 D segment for final test H1 element vector by checking tolerance-based numerical results, exact expected values.

TEST(FinalTest_H1Element_Vector, QuadraticVectorFieldReproduction_P2_Segment)

Verifies quadratic vector field reproduction P 2 segment for final test H1 element vector by checking tolerance-based numerical results.

TEST(FinalTest_H1Element_Vector, PartitionOfUnity_P3_P4_3D_Triangle)

P3 on Triangle with 3D vectors.

TEST(FinalTest_Integration, AllElementsAllTypes_DOFCounting)

Verify DOF counting formulas are correct for all elements and types.

TEST(FinalTest_Integration, AllElementsAllTypes_OrderProperty)

Verify order property is correct.

TEST(FinalTest_H1Element_Comprehensive, H1Element_K1_AllGeometries)

Comprehensive tests for H1Element<1> across all geometries.

TEST(FinalTest_H1Element_Comprehensive, H1Element_K2_to_K6_Segment)

Comprehensive test of H1Element for K=2,3,4,5,6 on Segment.

TEST(FinalTest_H1Element_Comprehensive, H1Element_K2_to_K6_Triangle)

Test H1Element for K=2,3,4,5,6 on Triangle.

TEST(FinalTest_H1Element_Comprehensive, H1Element_K2_to_K6_AllGeometries_DOFCount)

Verify DOF counts for all K values and geometries.

TEST(FinalTest_H1Element_Comprehensive, VectorH1Element_AllVectorDimensions)

Test vector H1Element with vdim=1,2,3 for various K values.

TEST(FinalTest_H1Element_Comprehensive, H1Element_LagrangeProperty_AllOrders_Segment)

Test Lagrange property for all K values on Segment.

TEST(FinalTest_H1Element_LinearForm, ScalarLinearForm_K0_to_K6_Segment)

Test LinearForm for all polynomial orders on Segment.

TEST(FinalTest_H1Element_LinearForm, VectorLinearForm_K0_to_K3_AllVectorDimensions)

Test LinearForm for vector Pk elements.

TEST(FinalTest_H1Element_GradientFunction, GradientConsistency_K1_to_K6)

Test gradient functions for polynomial orders 1-6.

TEST(FinalTest_H1Element_GradientFunction, GradientPartitionProperty_K2_Triangle)

Test that sum of gradients equals zero (partition of unity).

TEST(FinalTest_H1Element_JacobianFunction, JacobianStructure_K0_to_K3)

Test Jacobian function for vector Pk elements.

TEST(FinalTest_H1Element_JacobianFunction, Jacobian2D_K2_Triangle)

Test 2D Jacobian for K=2 on triangle.

TEST(FinalTest_H1Element_Interpolation, PolynomialInterpolation_K0_to_K6)

Test that Pk element exactly interpolates polynomials of degree K.

TEST(FinalTest_H1Element_Interpolation, VectorPolynomialInterpolation_K1_K2_K3)

Test vector field interpolation for Pk elements.

TEST(FinalTest_H1Element_Interpolation, GradientInterpolationConsistency_K2_K3)

Test that gradient of interpolant matches derivative of function.

TEST(Rodin_Variational_H1QuadratureRule, MixedOrder_GradGrad_Assembles)

Verifies mixed order grad grad assembles for variational H1 quadrature rule by checking exact expected values, form assembly.

TEST(Rodin_Variational_H1QuadratureRule, MixedOrder_Jacobian_Assembles)

Verifies mixed order jacobian assembles for variational H1 quadrature rule by checking exact expected values, form assembly.

TEST(Rodin_Variational_H1QuadratureRule, VectorMass_MatchesGridFunctionLinearForm)

Verifies vector mass matches grid function linear form for variational H1 quadrature rule by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Rodin_Variational_H1_Space, Triangle_VertexNodes_MatchConnectivity)

Verifies triangle vertex nodes match connectivity for variational H1 space by checking exact expected values, mesh connectivity computation.

TEST(Rodin_Variational_H1_Space, GlobalIndex_MatchesGetDOFs_ForVertices)

Verifies global index matches get DO fs for vertices for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Pushforward_PointBasis_IsOneAtVertex)

Verifies pushforward point basis is one at vertex for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Project_OneTriangle_AtNodes)

1 element mesh, triangle with vertices (0,0), (1,0), (0,1).

TEST(Rodin_Variational_H1_Space, SanityTest_H1_1_2D_Square_Build)

Verifies sanity test H1 1 2 D square build for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Pyramid_H1_2_UniformGrid_Build)

Verifies pyramid H1 2 uniform grid build for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, SanityTest_H1_2_2D_Square_Build)

Verifies sanity test H1 2 2 D square build for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, SanityTest_H1_3_2D_Square_Build)

Verifies sanity test H1 3 2 D square build for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, SanityTest_H1_2_UniformGrid)

Verifies sanity test H1 2 uniform grid for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, FiniteElement_H1_2)

Verifies finite element H1 2 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, GetDOFs_H1_2)

Verifies get DO fs H1 2 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, H1_1_MatchesP1_Size)

Verifies H1 1 matches P1 size for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, VectorH1_2_Build)

Verifies vector H1 2 build for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, H1_1_TrialTestFunction)

Verifies H1 1 trial test function for variational H1 space.

TEST(Rodin_Variational_H1_Space, H1_2_TrialTestFunction)

Verifies H1 2 trial test function for variational H1 space.

TEST(Rodin_Variational_H1_Space, DOFCount_Consistency)

Verifies DOF count consistency for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, GlobalIndex_MatchesGetDOFs)

Verifies global index matches get DO fs for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, ClosuresCoverAllGlobalDOFs_H1_2)

Verifies closures cover all global DO fs H1 2 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, CellClosure_DecomposesIntoSubentities_H1_3)

Verifies cell closure decomposes into subentities H1 3 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, VectorH1_EntityDOFScaling_H1_2)

Verifies vector H1 entity DOF scaling H1 2 for variational H1 space by checking exact expected values.

auto expectedDOFCount2D(size_t K, size_t vertexCount, size_t edgeCount, size_t cellCount) -> size_t

Helper used by the tests to Expected DOF Count 2 D.

TEST(Rodin_Variational_H1_Space, SanityTest_H1_4_2D_Square_Build)

Verifies sanity test H1 4 2 D square build for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, SanityTest_H1_5_2D_Square_Build)

Verifies sanity test H1 5 2 D square build for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, SanityTest_H1_6_2D_Square_Build)

Verifies sanity test H1 6 2 D square build for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, DOFCount_K1_to_K6_UniformGrid)

Verifies DOF count K 1 to K 6 uniform grid for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, FiniteElement_K4_to_K6)

Verifies finite element K 4 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, CellClosure_DecomposesIntoSubentities_H1_4)

Verifies cell closure decomposes into subentities H1 4 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, CellClosure_DecomposesIntoSubentities_H1_5)

Verifies cell closure decomposes into subentities H1 5 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, CellClosure_DecomposesIntoSubentities_H1_6)

Verifies cell closure decomposes into subentities H1 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, GlobalIndex_MatchesGetDOFs_K4_to_K6)

Verifies global index matches get DO fs K 4 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, ClosuresCoverAllGlobalDOFs_K4_to_K6)

Verifies closures cover all global DO fs K 4 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, TrialTestFunction_K4_to_K6)

Verifies trial test function K 4 to K 6 for variational H1 space.

TEST(Rodin_Variational_H1_Space, VectorH1_EntityDOFScaling_K4_to_K6)

Verifies vector H1 entity DOF scaling K 4 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, EdgeDOFCount_K1_to_K6)

Verifies edge DOF count K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, VertexDOFCount_K1_to_K6)

Verifies vertex DOF count K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, DOFIndices_Contiguous_K1_to_K6)

Verifies DOF indices contiguous K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, CellClosureSize_MatchesElementDOFCount_K1_to_K6)

Verifies cell closure size matches element DOF count K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_GridFunction_H1_2)

Verifies interpolation grid function H1 2 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_GridFunction_H1_3)

Verifies interpolation grid function H1 3 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_GridFunction_H1_4)

Verifies interpolation grid function H1 4 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_GridFunction_H1_5)

Verifies interpolation grid function H1 5 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_GridFunction_H1_6)

Verifies interpolation grid function H1 6 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, DOFCount_16x16_Mesh_K1_to_K6)

Verifies DOF count 16 x 16 mesh K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, GlobalIndex_16x16_Mesh_K1_to_K6)

Verifies global index 16 x 16 mesh K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_16x16_Mesh_H1_3)

Verifies interpolation 16 x 16 mesh H1 3 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, VectorH1_DOFCount_K1_to_K6)

Verifies vector H1 DOF count K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, VectorH1_GridFunction_K1_to_K6)

Verifies vector H1 grid function K 1 to K 6 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, VectorGridFunctionEvaluationAtCellInterior)

Verifies scalar and vector H1 evaluation at an interior cell point.

TEST(Rodin_Variational_H1_Space, P2EvaluationMatchesMappedBasisExpansion)

Verifies scalar and vector P2 evaluation against mapped-basis expansion.

TEST(Rodin_Variational_H1_Space, VectorH1_16x16_Mesh_K1_to_K6)

Verifies vector H1 16 x 16 mesh K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, VectorH1_3D_Vector_K1_to_K6)

Verifies vector H1 3 D vector K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, ComplexH1_Construction_K1_to_K6)

Verifies complex H1 construction K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, ComplexH1_GlobalIndex_K2)

Verifies complex H1 global index K 2 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, ComplexH1_16x16_Mesh_K1_to_K6)

Verifies complex H1 16 x 16 mesh K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, EdgeCase_SingleCell_K1_to_K6)

Verifies edge case single cell K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, EdgeCase_TwoCells_K1_to_K6)

Verifies edge case two cells K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, EdgeCase_8x8_Mesh_K1_to_K6)

Verifies edge case 8 x 8 mesh K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, IndexingRange_K1_to_K6)

Verifies indexing range K 1 to K 6 for variational H1 space.

TEST(Rodin_Variational_H1_Space, ElementDOFCount_AllCells_K1_to_K6)

Verifies element DOF count all cells K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, TrialTestFunction_VariousMeshSizes)

2x2 mesh.

TEST(Rodin_Variational_H1_Space, VectorH1_Indexing_K1_to_K6)

Verifies vector H1 indexing K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Segment_H1_1_DOFCount)

Verifies segment H1 1 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Segment_H1_2_DOFCount)

Verifies segment H1 2 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Segment_H1_3_DOFCount)

Verifies segment H1 3 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Segment_H1_K1_to_K6_Indexing)

Verifies segment H1 K 1 to K 6 indexing for variational H1 space.

TEST(Rodin_Variational_H1_Space, Segment_TrialTestFunction)

Verifies segment trial test function for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Segment_VectorH1_DOFCount)

Verifies segment vector H1 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Quadrilateral_H1_1_DOFCount)

Verifies quadrilateral H1 1 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Quadrilateral_H1_2_DOFCount)

Verifies quadrilateral H1 2 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Quadrilateral_H1_3_DOFCount)

Verifies quadrilateral H1 3 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Quadrilateral_H1_K1_to_K6_Indexing)

Verifies quadrilateral H1 K 1 to K 6 indexing for variational H1 space.

TEST(Rodin_Variational_H1_Space, Quadrilateral_8x8_DOFCount_K1_to_K6)

Verifies quadrilateral 8 x 8 DOF count K 1 to K 6 for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Quadrilateral_TrialTestFunction)

Verifies quadrilateral trial test function for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Quadrilateral_VectorH1_DOFCount)

Verifies quadrilateral vector H1 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Quadrilateral_ComplexH1_DOFCount)

Verifies quadrilateral complex H1 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Tetrahedron_H1_1_DOFCount)

Verifies tetrahedron H1 1 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Tetrahedron_H1_2_DOFCount)

Verifies tetrahedron H1 2 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Tetrahedron_H1_3_DOFCount)

Verifies tetrahedron H1 3 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Tetrahedron_H1_4_DOFCount)

Verifies tetrahedron H1 4 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Tetrahedron_H1_K1_to_K6_Indexing)

Verifies tetrahedron H1 K 1 to K 6 indexing for variational H1 space.

TEST(Rodin_Variational_H1_Space, Tetrahedron_TrialTestFunction)

Verifies tetrahedron trial test function for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Tetrahedron_VectorH1_DOFCount)

Verifies tetrahedron vector H1 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Tetrahedron_ComplexH1_DOFCount)

Verifies tetrahedron complex H1 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Wedge_H1_1_DOFCount)

Verifies wedge H1 1 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Wedge_H1_2_DOFCount)

Verifies wedge H1 2 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Wedge_H1_K1_to_K6_Indexing)

Verifies wedge H1 K 1 to K 6 indexing for variational H1 space.

TEST(Rodin_Variational_H1_Space, Wedge_TrialTestFunction)

Verifies wedge trial test function for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, Wedge_VectorH1_DOFCount)

Verifies wedge vector H1 DOF count for variational H1 space by checking exact expected values.

TEST(Rodin_Variational_H1_Space, AllGeometries_H1_1_ConsistentVertexDOF)

Test that H1<1> always gives 1 DOF per vertex across all geometries.

TEST(Rodin_Variational_H1_Space, AllGeometries_H1_2_VertexPlusEdge)

Test that H1<2> gives correct DOF counts across all geometries.

TEST(Rodin_Variational_H1_Space, AllGeometries_GridFunction_Creation)

Test that GridFunction can be created across all geometries.

TEST(Rodin_Variational_H1_Space, Interpolation_Segment_H1_2)

Verifies interpolation segment H1 2 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Segment_H1_3)

Verifies interpolation segment H1 3 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Segment_H1_6)

Verifies interpolation segment H1 6 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Quadrilateral_H1_2)

Verifies interpolation quadrilateral H1 2 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Quadrilateral_H1_3)

Verifies interpolation quadrilateral H1 3 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Quadrilateral_H1_6)

Verifies interpolation quadrilateral H1 6 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Tetrahedron_H1_2)

Verifies interpolation tetrahedron H1 2 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Tetrahedron_H1_3)

Verifies interpolation tetrahedron H1 3 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Tetrahedron_H1_6)

Verifies interpolation tetrahedron H1 6 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Wedge_H1_2)

Verifies interpolation wedge H1 2 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Wedge_H1_3)

Verifies interpolation wedge H1 3 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Wedge_H1_6)

Verifies interpolation wedge H1 6 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Hexahedron_H1_2)

Verifies interpolation hexahedron H1 2 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Hexahedron_H1_3)

Verifies interpolation hexahedron H1 3 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Hexahedron_H1_6)

Verifies interpolation hexahedron H1 6 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Triangle_H1_2_4x4)

Verifies interpolation triangle H1 2 4 x 4 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Triangle_H1_3_4x4)

Verifies interpolation triangle H1 3 4 x 4 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Triangle_H1_6_4x4)

Verifies interpolation triangle H1 6 4 x 4 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Triangle_8x8_H1_3)

Verifies interpolation triangle 8 x 8 H1 3 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Quadrilateral_8x8_H1_3)

Verifies interpolation quadrilateral 8 x 8 H1 3 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_Segment_8x8_H1_3)

Verifies interpolation segment 8 x 8 H1 3 for variational H1 space by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_H1_Space, Interpolation_SingleCell_Triangle_H1_3)

Single triangle mesh.

TEST(Rodin_Variational_H1_Space, Interpolation_SingleCell_Quadrilateral_H1_3)

Small 3x3 quadrilateral mesh (9 cells) for edge case testing.

TEST(Rodin_Variational_H1_Space, Interpolation_SingleCell_Segment_H1_3)

Single segment mesh.

TEST(Rodin_Variational_H1_Space, Interpolation_SingleCell_Tetrahedron_H1_3)

Small tetrahedron mesh for edge case testing.

TEST(Rodin_Variational_H1_Space, Interpolation_SingleCell_Wedge_H1_3)

Small wedge mesh for edge case testing.

TEST(Rodin_Variational_H1_Space, Projection_Segment_H1_2_NonTrivialMesh)

Non-trivial 1D mesh with 10 segments.

TEST(Rodin_Variational_H1_Space, Interpolation_Segment_H1_3_NonTrivialMesh)

Non-trivial 1D mesh with 12 segments.

TEST(Rodin_Variational_H1_Space, Projection_Triangle_H1_2_NonTrivialMesh)

Non-trivial 2D triangle mesh (6x6 grid).

TEST(Rodin_Variational_H1_Space, Interpolation_Triangle_H1_3_NonTrivialMesh)

Non-trivial 2D triangle mesh (5x5 grid).

TEST(Rodin_Variational_H1_Space, Projection_Triangle_H1_4_NonTrivialMesh)

Non-trivial 2D triangle mesh (4x4 grid).

TEST(Rodin_Variational_H1_Space, Projection_Quadrilateral_H1_2_NonTrivialMesh)

Non-trivial 2D quadrilateral mesh (6x6 grid).

TEST(Rodin_Variational_H1_Space, Interpolation_Quadrilateral_H1_3_NonTrivialMesh)

Non-trivial 2D quadrilateral mesh (5x5 grid).

TEST(Rodin_Variational_H1_Space, Projection_Tetrahedron_H1_2_NonTrivialMesh)

Non-trivial 3D tetrahedron mesh (3x3x3 grid).

TEST(Rodin_Variational_H1_Space, Interpolation_Tetrahedron_H1_3_NonTrivialMesh)

Non-trivial 3D tetrahedron mesh (3x3x3 grid).

TEST(Rodin_Variational_H1_Space, Projection_Tetrahedron_H1_4_NonTrivialMesh)

Non-trivial 3D tetrahedron mesh (2x2x2 grid).

TEST(Rodin_Variational_H1_Space, Projection_Wedge_H1_2_NonTrivialMesh)

Non-trivial 3D wedge mesh (3x3x3 grid).

TEST(Rodin_Variational_H1_Space, Interpolation_Wedge_H1_3_NonTrivialMesh)

Non-trivial 3D wedge mesh (3x3x3 grid).

TEST(Rodin_Variational_H1_Space, Projection_Triangle_H1_3_LargeNonTrivialMesh)

Large non-trivial 2D triangle mesh (12x12 grid).

TEST(Rodin_Variational_H1_Space, Interpolation_Tetrahedron_H1_2_LargeNonTrivialMesh)

Large non-trivial 3D tetrahedron mesh (4x4x4 grid).

TEST(Rodin_Variational_H1_Space, Projection_Tetrahedron_H1_2_RefinedNonTrivialMesh)

Refined non-trivial 3D tetrahedron mesh (5x5x5 grid, 750 tets).

TEST(Rodin_Variational_H1_Space, Interpolation_Tetrahedron_H1_3_RefinedNonTrivialMesh)

Refined non-trivial 3D tetrahedron mesh (4x4x4 grid, 384 tets).

TEST(Rodin_Variational_H1_Space, Projection_Tetrahedron_H1_4_RefinedNonTrivialMesh)

Refined non-trivial 3D tetrahedron mesh (3x3x3 grid, 162 tets).

TEST(Rodin_Variational_H1_Space, Projection_Wedge_H1_2_RefinedNonTrivialMesh)

Refined non-trivial 3D wedge mesh (5x5x5 grid, 250 wedges).

TEST(Rodin_Variational_H1_Space, Interpolation_Wedge_H1_3_RefinedNonTrivialMesh)

Refined non-trivial 3D wedge mesh (4x4x4 grid, 128 wedges).

TEST(Rodin_Variational_H1_Space, Projection_Wedge_H1_4_RefinedNonTrivialMesh)

Refined non-trivial 3D wedge mesh (3x3x3 grid, 54 wedges).

TEST(Rodin_Variational_H1_Space, NonTrivialGeometry_SquareWithHole_H1_2_Projection)

Load SquareWithHole mesh (2D - square with circular hole).

TEST(Rodin_Variational_H1_Space, NonTrivialGeometry_SquareWithHole_H1_3_Interpolation)

Load SquareWithHole mesh (2D - square with circular hole).

TEST(Rodin_Variational_H1_Space, NonTrivialGeometry_StarSquare_H1_2_Projection)

Load StarSquare mesh (2D - star-shaped domain with quadrilateral elements).

TEST(Rodin_Variational_H1_Space, NonTrivialGeometry_StarSquare_H1_3_Interpolation)

Load StarSquare mesh (2D - star-shaped domain).

TEST(Rodin_Variational_H1_Space, NonTrivialGeometry_LevelSetCantilever_H1_3_Interpolation)

Load LevelSetCantilever mesh (2D - cantilever beam geometry).

TEST(Rodin_Variational_Integral, TestFunction_Construction)

Verifies test function construction for variational integral by checking exact expected values.

TEST(Rodin_Variational_Integral, TestFunction_Copy)

Verifies test function copy for variational integral by checking exact expected values, copy semantics.

TEST(Rodin_Variational_Integral, GridFunction_Construction)

Verifies grid function construction for variational integral by checking exact expected values.

TEST(Rodin_Variational_Integral, GridFunction_Copy)

Verifies grid function copy for variational integral by checking exact expected values, copy semantics.

TEST(Rodin_Variational_Integral, Dot_ShapeFunctions_Construction)

Verifies dot shape functions construction for variational integral by checking exact expected values.

TEST(Rodin_Variational_Integral, Dot_ShapeFunctions_Copy)

Verifies dot shape functions copy for variational integral by checking exact expected values, copy semantics.

TEST(Rodin_Variational_Integral, InLinearForm_Assembly)

Verifies in linear form assembly for variational integral by checking form assembly.

TEST(Rodin_Variational_Integral, InBilinearForm_MassMatrix)

Verifies in bilinear form mass matrix for variational integral by checking exact expected values, form assembly.

TEST(Rodin_Variational_Integral, InBilinearForm_StiffnessMatrix)

Verifies in bilinear form stiffness matrix for variational integral by checking exact expected values, form assembly.

TEST(Rodin_Variational_Integral, GridFunction_ConstantFunction)

Verifies grid function constant function for variational integral by checking exact expected values.

TEST(Rodin_Variational_Integral, VectorFunction_Components)

Verifies vector function components for variational integral by checking exact expected values.

TEST(Rodin_Variational_Integral, MoveConstructor)

Verifies move constructor for variational integral by checking exact expected values, move semantics.

TEST(Rodin_Variational_Integral, CopyConstructor)

Verifies copy constructor for variational integral by checking exact expected values, copy semantics.

TEST(Rodin_Variational_Integral, WithRealFunction_InLinearForm)

Verifies with real function in linear form for variational integral by checking form assembly.

TEST(Rodin_Variational_Integral, MultipleIntegrators)

Verifies multiple integrators for variational integral by checking form assembly.

TEST(Rodin_Variational_Integral, LinearForm_WithVectorFunction)

Verifies linear form with vector function for variational integral by checking form assembly.

auto findInteriorFacePoint(Geometry::Mesh<Context::Local>& mesh) -> std::pair<bool, Geometry::Point>

Finds an interior face in the mesh and returns a point at its midpoint.

TEST(Rodin_Variational_Jump, ConstantFunction_JumpIsZero)

Jump of a constant across any interior face should be zero.

TEST(Rodin_Variational_Jump, ConstantVectorFunction_JumpIsZero)

Jump of a constant vector function should be a zero vector.

TEST(Rodin_Variational_Jump, GridFunction_ContinuousFunction_JumpIsZero)

Jump of a continuous P1 grid function across an interior face should be zero.

TEST(Rodin_Variational_Jump, CopyConstruction)

Verifies copy construction for variational jump by checking tolerance-based numerical results, true predicates, copy semantics.

TEST(Rodin_Variational_Jump, MoveConstruction)

Verifies move construction for variational jump by checking tolerance-based numerical results, true predicates, move semantics.

TEST(Rodin_Variational_Jump, PolymorphicCopy)

Verifies polymorphic copy for variational jump by checking tolerance-based numerical results, true predicates, copy semantics.

TEST(Rodin_Variational_Real_P1_LinearForm, SanityTest_Build)

Verifies sanity test build for variational real P1 linear form by checking exact expected values.

TEST(Rodin_Variational_Real_P1_LinearForm, FuzzyTest_UniformGrid_4x4)

Verifies fuzzy test uniform grid 4 x 4 for variational real P1 linear form by checking form assembly.

TEST(Rodin_Variational_Real_P1_LinearForm, CopyConstructor)

Verifies copy constructor for variational real P1 linear form by checking exact expected values, copy semantics.

TEST(Rodin_Variational_Real_P1_LinearForm, MoveConstructor)

Verifies move constructor for variational real P1 linear form by checking exact expected values, move semantics.

TEST(Rodin_Variational_Real_P1_LinearForm, Assignment)

Verifies assignment for variational real P1 linear form by checking false predicates.

TEST(Rodin_Variational_Real_P1_LinearForm, AdditionAssignment)

Verifies addition assignment for variational real P1 linear form by checking false predicates.

TEST(Rodin_Variational_Real_P1_LinearForm, SubtractionAssignment)

Verifies subtraction assignment for variational real P1 linear form by checking false predicates.

TEST(Rodin_Variational_Real_P1_LinearForm, AssembleAndGetVector)

Verifies assemble and get vector for variational real P1 linear form by checking exact expected values, form assembly.

TEST(Rodin_Variational_Real_P1_LinearForm, Copy)

Verifies copy for variational real P1 linear form by checking copy semantics.

TEST(Rodin_Variational_Vector_P1_LinearForm, SanityTest_Build)

Verifies sanity test build for variational vector P1 linear form by checking exact expected values.

TEST(Rodin_Variational_Vector_P1_LinearForm, AssembleVectorFunction)

Verifies assemble vector function for variational vector P1 linear form by checking form assembly.

TEST(Rodin_Variational_Real_P1_LinearForm, ClearIntegrators)

Verifies clear integrators for variational real P1 linear form by checking false predicates.

TEST(Rodin_Variational_Max, RealFunction_TwoValues)

Verifies real function two values for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, RealFunction_EqualValues)

Verifies real function equal values for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, RealFunction_NegativeValues)

Verifies real function negative values for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, RealFunction_MixedSigns)

Verifies real function mixed signs for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, RealFunction_WithZero)

Verifies real function with zero for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, RealFunction_SmallValues)

Verifies real function small values for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, GridFunction_Maximum)

Verifies grid function maximum for variational max by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Max, ChainedMaximum)

Verifies chained maximum for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, Commutativity)

Verifies commutativity for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, Associativity)

Verifies associativity for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, Idempotence)

Verifies idempotence for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, LargeValues)

Verifies large values for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, MaxWithOperations)

Verifies max with operations for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, MaxMonotonicity)

Verifies max monotonicity for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, MaxWithAbsoluteValue)

Verifies max with absolute value for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, FractionalValues)

Verifies fractional values for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, MaxMinRelationship)

Verifies max min relationship for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, MaxWithPow)

Verifies max with pow for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Max, NegativeZeroComparison)

Verifies negative zero comparison for variational max by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, RealFunction_TwoValues)

Verifies real function two values for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, RealFunction_EqualValues)

Verifies real function equal values for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, RealFunction_NegativeValues)

Verifies real function negative values for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, RealFunction_MixedSigns)

Verifies real function mixed signs for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, RealFunction_WithZero)

Verifies real function with zero for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, RealFunction_SmallValues)

Verifies real function small values for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, GridFunction_Minimum)

Verifies grid function minimum for variational min by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Min, ChainedMinimum)

Verifies chained minimum for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, Commutativity)

Verifies commutativity for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, Associativity)

Verifies associativity for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, Idempotence)

Verifies idempotence for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, LargeValues)

Verifies large values for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, MinWithOperations)

Verifies min with operations for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, MinMonotonicity)

Verifies min monotonicity for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, MinWithAbsoluteValue)

Verifies min with absolute value for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Min, FractionalValues)

Verifies fractional values for variational min by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, RealFunction_Subtraction)

Verifies real function subtraction for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, RealFunction_ZeroResult)

Verifies real function zero result for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, RealFunction_NegativeResult)

Verifies real function negative result for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, RealFunction_SubtractZero)

Verifies real function subtract zero for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, RealFunction_NegativeNumbers)

Verifies real function negative numbers for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, RealFunction_MixedSigns)

Verifies real function mixed signs for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, VectorFunction_Subtraction)

Verifies vector function subtraction for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, VectorFunction_ZeroVector)

Verifies vector function zero vector for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, GridFunction_Subtraction)

Verifies grid function subtraction for variational minus by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Minus, ChainedSubtraction)

Verifies chained subtraction for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, SubtractionWithAddition)

Verifies subtraction with addition for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, SubtractionSelfInverse)

Verifies subtraction self inverse for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, SubtractionNonCommutative)

Verifies subtraction non commutative for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, SubtractionWithMultiplication)

Verifies subtraction with multiplication for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, SubtractionWithDivision)

Verifies subtraction with division for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, LargeValues)

Verifies large values for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, SmallValues)

Verifies small values for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, SubtractFromSelf)

Verifies subtract from self for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, SubtractionWithSqrt)

Verifies subtraction with sqrt for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, SubtractionWithAbs)

Verifies subtraction with abs for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, VectorComponentSubtraction)

Verifies vector component subtraction for variational minus by checking tolerance-based numerical results.

TEST(Rodin_Variational_Minus, SubtractionFractionalValues)

Verifies subtraction fractional values for variational minus by checking tolerance-based numerical results.

TEST(MixedProblem_PreassembledBF, SparseP0P1_MatrixMatchesIntegralOnly)

Mixed P0/P1 problem: compare integral-only vs preassembled BF.

TEST(MixedProblem_PreassembledLF, SparseP0P1_VectorMatchesIntegralOnly)

Same test for the RHS vector: compare integral-only vs preassembled LinearForm.

TEST(MixedProblem_PreassembledBF, SolveP0P1_SolutionMatches)

Verify that a solve using preassembled BF in a mixed Problem produces the same numerical solution as the integral-only version.

TEST(MixedProblem_PreassembledLF, SolveP0P1_SolutionMatches)

Verify that a solve using preassembled LF in a mixed Problem produces the same numerical solution as the integral-only version.

TEST(Rodin_Variational_Mult, RealFunction_Multiplication)

Verifies real function multiplication for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, RealFunction_ZeroMultiplication)

Verifies real function zero multiplication for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, RealFunction_OneMultiplication)

Verifies real function one multiplication for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, RealFunction_NegativeMultiplication)

Verifies real function negative multiplication for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, ScalarVectorMultiplication)

Verifies scalar vector multiplication for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, VectorScalarMultiplication)

Verifies vector scalar multiplication for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, GridFunction_Multiplication)

Verifies grid function multiplication for variational mult by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Mult, TrialFunction_ScalarMultiplication)

Verifies trial function scalar multiplication for variational mult.

TEST(Rodin_Variational_Mult, TestFunction_ScalarMultiplication)

Verifies test function scalar multiplication for variational mult.

TEST(Rodin_Variational_Mult, ChainedMultiplication)

Verifies chained multiplication for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, AssociativityTest)

Verifies associativity test for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, CommutativityTest)

Verifies commutativity test for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, FractionalMultiplication)

Verifies fractional multiplication for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, LargeValueMultiplication)

Verifies large value multiplication for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_Mult, VectorComponentMultiplication)

Verifies vector component multiplication for variational mult by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP0Element, SanityTest_0D_Reference_Point)

Verifies sanity test 0 D reference point for variational real P0 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP0Element, SanityTest_1D_Reference_Segment)

Verifies sanity test 1 D reference segment for variational real P0 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP0Element, DerivativeTest_1D_Reference_Segment)

Verifies derivative test 1 D reference segment for variational real P0 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP0Element, SanityTest_2D_Reference_Triangle)

Verifies sanity test 2 D reference triangle for variational real P0 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP0Element, DerivativeTest_2D_Reference_Triangle)

Verifies derivative test 2 D reference triangle for variational real P0 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP0Element, SanityTest_2D_Reference_Quadrilateral)

Verifies sanity test 2 D reference quadrilateral for variational real P0 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP0Element, SanityTest_3D_Reference_Tetrahedron)

Verifies sanity test 3 D reference tetrahedron for variational real P0 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP0Element, DerivativeTest_3D_Reference_Tetrahedron)

Verifies derivative test 3 D reference tetrahedron for variational real P0 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP0Element, FuzzyTest_AllGeometries)

Verifies fuzzy test all geometries for variational real P0 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP0Element, SanityTest_3D_Reference_Wedge)

Verifies sanity test 3 D reference wedge for variational real P0 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP0Element, SanityTest_3D_Reference_Pyramid)

Verifies sanity test 3 D reference pyramid for variational real P0 element by checking tolerance-based numerical results, exact expected values.

TEST(FinalTest_P0Element_Real, PartitionOfUnity_AllGeometries)

Verifies partition of unity all geometries for final test P0 element real by checking tolerance-based numerical results.

TEST(FinalTest_P0Element_Real, ConstantReproduction_AllGeometries)

P0 should exactly reproduce constant functions.

TEST(FinalTest_P0Element_Real, ZeroDerivatives_AllGeometries)

All derivatives of P0 elements should be zero.

TEST(FinalTest_P0Element_Complex, PartitionOfUnity_AllGeometries)

Verifies partition of unity all geometries for final test P0 element complex by checking tolerance-based numerical results.

TEST(FinalTest_P0Element_Complex, ComplexArithmetic)

Verifies complex arithmetic for final test P0 element complex by checking tolerance-based numerical results.

TEST(FinalTest_P0Element_Vector, ComponentStructure_2D)

Verifies component structure 2 D for final test P0 element vector by checking tolerance-based numerical results, exact expected values.

TEST(FinalTest_P0Element_Vector, ComponentStructure_3D)

Verifies component structure 3 D for final test P0 element vector by checking tolerance-based numerical results, exact expected values.

TEST(FinalTest_P0Element_Vector, VectorFieldReproduction)

Verifies vector field reproduction for final test P0 element vector by checking tolerance-based numerical results.

TEST(FinalTest_P0Element_Vector, VectorDimensions_1D_2D_3D_AllGeometries)

Test vdim=1, 2, 3 on Segment.

TEST(FinalTest_P0Element_Vector, PartitionOfUnity_AllVectorDimensions)

Verifies partition of unity all vector dimensions for final test P0 element vector by checking tolerance-based numerical results.

TEST(FinalTest_P0Element_LinearForm, LinearForm_AllGeometries)

Test LinearForm evaluation for P0 elements across all geometries.

TEST(FinalTest_P0Element_LinearForm, VectorLinearForm_AllVectorDimensions)

Test LinearForm for vector P0 elements with different vector dimensions.

TEST(FinalTest_P0Element_Interpolation, ScalarConstantInterpolation)

Test that P0 element correctly interpolates constant functions.

TEST(FinalTest_P0Element_Interpolation, VectorConstantInterpolation)

Test vector P0 element interpolation for constant vector fields.

TEST(FinalTest_P0Element_Interpolation, InterpolationAccuracy_MultiplePoints)

Test interpolation accuracy at multiple points for P0 element.

TEST(Rodin_Variational_P0g, ScalarConstruction)

Verifies scalar construction for variational P0 g by checking exact expected values.

TEST(Rodin_Variational_P0g, ScalarGridFunctionProjection)

Verifies scalar grid function projection for variational P0 g by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_P0g, ScalarDOFsMapping)

Verifies scalar DO fs mapping for variational P0 g by checking exact expected values.

TEST(Rodin_Variational_P0g, VectorConstruction)

Verifies vector construction for variational P0 g by checking exact expected values.

TEST(Rodin_Variational_P0g, VectorDOFsMapping)

Verifies vector DO fs mapping for variational P0 g by checking exact expected values.

TEST(Rodin_Variational_P0g, GridFunctionEvaluation)

Verifies scalar and vector P0g grid-function evaluation.

TEST(Rodin_Variational_P0g, ScalarElementProperties)

Verifies scalar element properties for variational P0 g by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_P0g, GradOfScalarGridFunctionIsZero)

Verifies grad of scalar grid function is zero for variational P0 g by checking tolerance-based numerical results.

TEST(Rodin_Variational_P0g, GradOrder)

Verifies grad order for variational P0 g by checking exact expected values, true predicates.

TEST(Rodin_Variational_P0g, DivOfVectorGridFunctionIsZero)

Verifies div of vector grid function is zero for variational P0 g by checking tolerance-based numerical results.

TEST(Rodin_Variational_P0g, JacobianOfVectorGridFunctionIsZero)

Verifies jacobian of vector grid function is zero for variational P0 g by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, SanityTest_1D_Reference_Segment)

Verifies sanity test 1 D reference segment for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, FuzzyTest_1D_Reference_Segment)

Verifies fuzzy test 1 D reference segment for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, SanityTest_2D_Reference_Triangle)

Verifies sanity test 2 D reference triangle for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, FuzzyTest_2D_Reference_Triangle)

Verifies fuzzy test 2 D reference triangle for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, ElementProperties_Segment)

Verifies element properties segment for variational real P1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP1Element, ElementProperties_Triangle)

Verifies element properties triangle for variational real P1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP1Element, DerivativeTest_1D_Reference_Segment)

Verifies derivative test 1 D reference segment for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, DerivativeTest_2D_Reference_Triangle)

Verifies derivative test 2 D reference triangle for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, GradientTest_2D_Reference_Triangle)

Verifies gradient test 2 D reference triangle for variational real P1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP1Element, PartitionOfUnity_Segment)

Verifies partition of unity segment for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, PartitionOfUnity_Triangle)

Verifies partition of unity triangle for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, SanityTest_3D_Reference_Tetrahedron)

Verifies sanity test 3 D reference tetrahedron for variational real P1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP1Element, PartitionOfUnity_Tetrahedron)

Verifies partition of unity tetrahedron for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, SanityTest_3D_Reference_Pyramid)

Verifies sanity test 3 D reference pyramid for variational real P1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP1Element, LinearReproduction_Pyramid)

Verifies linear reproduction pyramid for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, SanityTest_2D_Reference_Quadrilateral)

Verifies sanity test 2 D reference quadrilateral for variational real P1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP1Element, PartitionOfUnity_Quadrilateral)

Verifies partition of unity quadrilateral for variational real P1 element by checking tolerance-based numerical results.

TEST(FinalTest_P1Element_Real, PartitionOfUnity_AllGeometries)

Verifies partition of unity all geometries for final test P1 element real by checking tolerance-based numerical results.

TEST(FinalTest_P1Element_Real, LagrangeProperty_AllGeometries)

Segment.

TEST(FinalTest_P1Element_Real, LinearReproduction_Segment)

Verifies linear reproduction segment for final test P1 element real by checking tolerance-based numerical results.

TEST(FinalTest_P1Element_Real, LinearReproduction_Triangle)

Verifies linear reproduction triangle for final test P1 element real by checking tolerance-based numerical results.

TEST(FinalTest_P1Element_Real, ConstantDerivatives_Segment)

Verifies constant derivatives segment for final test P1 element real by checking tolerance-based numerical results.

TEST(FinalTest_P1Element_Complex, PartitionOfUnity_Segment)

Verifies partition of unity segment for final test P1 element complex by checking tolerance-based numerical results.

TEST(FinalTest_P1Element_Complex, ComplexLinearReproduction)

Verifies complex linear reproduction for final test P1 element complex by checking tolerance-based numerical results.

TEST(FinalTest_P1Element_Vector, ComponentStructure_2D_Segment)

Verifies component structure 2 D segment for final test P1 element vector by checking tolerance-based numerical results, exact expected values.

TEST(FinalTest_P1Element_Vector, LinearVectorFieldReproduction)

Verifies linear vector field reproduction for final test P1 element vector by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, SanityTest_3D_Reference_Wedge)

Verifies sanity test 3 D reference wedge for variational real P1 element by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_RealP1Element, PartitionOfUnity_Wedge)

Verifies partition of unity wedge for variational real P1 element by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealP1Element, DerivativeTest_3D_Reference_Wedge)

Verifies derivative test 3 D reference wedge for variational real P1 element by checking true predicates.

TEST(FinalTest_P1Element_Vector, VectorDimensions_1D_2D_3D_Segment)

Test vdim=1 (scalar-like).

TEST(FinalTest_P1Element_Vector, VectorDimensions_Triangle)

Test vdim=1 on Triangle.

TEST(FinalTest_P1Element_Vector, VectorDimensions_Tetrahedron)

Test vdim=3 on Tetrahedron (typical 3D case).

TEST(FinalTest_P1Element_Vector, VectorDimensions_Wedge)

Test vdim=3 on Wedge.

TEST(FinalTest_P1Element_Vector, VectorDimensions_Pyramid)

Verifies vector dimensions pyramid for final test P1 element vector by checking exact expected values.

TEST(FinalTest_P1Element_LinearForm, ScalarLinearForm_AllGeometries)

Test LinearForm evaluation for P1 elements across all geometries.

TEST(FinalTest_P1Element_LinearForm, VectorLinearForm_AllVectorDimensions)

Test LinearForm for vector P1 elements.

TEST(FinalTest_P1Element_GradientFunction, GradientConsistency_AllGeometries)

Test that gradient functions work correctly across geometries.

TEST(FinalTest_P1Element_GradientFunction, GradientPartitionProperty)

Test that sum of gradients equals zero (partition of unity property).

TEST(FinalTest_P1Element_JacobianFunction, JacobianStructure_AllVectorDimensions)

Test Jacobian function structure for vector P1 elements.

TEST(FinalTest_P1Element_JacobianFunction, Jacobian2D_Triangle)

Test Jacobian for 2D vector field on triangle.

TEST(FinalTest_P1Element_JacobianFunction, Jacobian3D_Tetrahedron)

Test Jacobian for 3D vector field on tetrahedron.

TEST(FinalTest_P1Element_Interpolation, LinearFunctionInterpolation_AllGeometries)

Test that P1 element exactly interpolates linear functions.

TEST(FinalTest_P1Element_Interpolation, VectorLinearFieldInterpolation)

Test vector field interpolation.

TEST(FinalTest_P1Element_Interpolation, GradientInterpolationConsistency)

Test that gradient of interpolant matches expected gradient.

TEST(Rodin_Variational_P1QuadratureRule, LinearForm_ScalarLinearCoefficient_UsesMultiPointQuadrature)

Verifies linear form scalar linear coefficient uses multi point quadrature for variational P1 quadrature rule by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, BilinearForm_LinearCoefficientMass_UsesMultiPointQuadrature)

Verifies bilinear form linear coefficient mass uses multi point quadrature for variational P1 quadrature rule by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, MixedSpaces_GradGrad_Assembles)

Verifies mixed spaces grad grad assembles for variational P1 quadrature rule by checking exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, MixedSpaces_VectorMass_Assembles)

Verifies mixed spaces vector mass assembles for variational P1 quadrature rule by checking exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, MixedSpaces_VectorMass_NoCoeff_Assembles)

Verifies mixed spaces vector mass no coeff assembles for variational P1 quadrature rule by checking exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, VectorMass_MatchesGridFunctionLinearForm)

Verifies vector mass matches grid function linear form for variational P1 quadrature rule by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, ScalarWeightedVectorMass_MatchesGridFunctionLinearForm)

Verifies scalar weighted vector mass matches grid function linear form for variational P1 quadrature rule by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, OuterScalarWeightedVectorMass_MatchesGridFunctionLinearForm)

Verifies outer scalar weighted vector mass matches grid function linear form for variational P1 quadrature rule by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, MatrixWeightedVectorMass_MatchesGridFunctionLinearForm)

Verifies matrix weighted vector mass matches grid function linear form for variational P1 quadrature rule by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, VectorPotentialConstantKernel_UsesSeparateTrialAndTestBasisValues)

Verifies vector potential constant kernel uses separate trial and test basis values for variational P1 quadrature rule by checking tolerance-based numerical results, exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, DivergencePressureCoupling_Assembles)

Verifies divergence pressure coupling assembles for variational P1 quadrature rule by checking exact expected values, form assembly.

TEST(Rodin_Variational_P1QuadratureRule, PressureDivergence_Assembles)

Verifies pressure divergence assembles for variational P1 quadrature rule by checking exact expected values, form assembly.

TEST(Rodin_Variational_Real_P1, SanityTest_2D_Square_Build)

Verifies sanity test 2 D square build for variational real P1 by checking exact expected values.

TEST(Rodin_Variational_Real_P1_GridFunction, SanityTest_2D_Square_Project_Sum)

Verifies sanity test 2 D square project sum for variational real P1 grid function by checking tolerance-based numerical results.

TEST(Rodin_Variational_Real_P1_GridFunction_FuzzyTest, TriangularUniformGrid16_ProjectOnBoundary_Constant)

Verifies triangular uniform grid 16 project on boundary constant for variational real P1 grid function fuzzy test by checking grid-function projection.

TEST(Rodin_Variational_Real_P1_GridFunction, FuzzyTest_TriangularUniformGrid16_ProjectOnBoundary_Sum)

Verifies fuzzy test triangular uniform grid 16 project on boundary sum for variational real P1 grid function by checking grid-function projection.

TEST(Rodin_Variational_Real_P1_GridFunction, FuzzyTest_2D_Square_Project_LinearFunction)

Verifies fuzzy test 2 D square project linear function for variational real P1 grid function by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Vector_P1, SanityTest_2D_Square_Build)

Verifies sanity test 2 D square build for variational vector P1 by checking exact expected values.

TEST(Rodin_Variational_Vector_P1_GridFunction, FuzzyTest_2D_Square_Project)

Verifies fuzzy test 2 D square project for variational vector P1 grid function by checking tolerance-based numerical results.

TEST(Rodin_Variational_Real_P1_TrialFunction, FuzzyTest_UniformGrid_4x4)

Verifies fuzzy test uniform grid 4 x 4 for variational real P1 trial function.

TEST(Rodin_Variational_Real_P1_TestFunction, FuzzyTest_UniformGrid_4x4)

Verifies fuzzy test uniform grid 4 x 4 for variational real P1 test function.

TEST(Rodin_Variational_Pow, RealFunction_SquareRoot)

Verifies real function square root for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, RealFunction_Square)

Verifies real function square for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, RealFunction_Cube)

Verifies real function cube for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, RealFunction_ZeroPower)

Verifies real function zero power for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, RealFunction_PowerOfOne)

Verifies real function power of one for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, RealFunction_NegativePower)

Verifies real function negative power for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, RealFunction_FractionalPower)

Verifies real function fractional power for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, GridFunction_PowerOperation)

Verifies grid function power operation for variational pow by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Pow, ChainedPowerOperations)

Verifies chained power operations for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, PowerOfZero)

Verifies power of zero for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, PowerOfOne)

Verifies power of one for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, LargeExponent)

Verifies large exponent for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, NegativeBasePower)

Verifies negative base power for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, EvenPowerNegativeBase)

Verifies even power negative base for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, PowerLawValidation)

Verifies power law validation for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, IntegerExponent)

Verifies integer exponent for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_Pow, SmallFractionalExponent)

Verifies small fractional exponent for variational pow by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealFunction, ConstantReal_Construction)

Verifies constant real construction for variational real function by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealFunction, ConstantInteger_Construction)

Verifies constant integer construction for variational real function by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealFunction, CopyConstructor_Real)

Verifies copy constructor real for variational real function by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_Variational_RealFunction, MoveConstructor_Real)

Verifies move constructor real for variational real function by checking tolerance-based numerical results, move semantics.

TEST(Rodin_Variational_RealFunction, Copy_Real)

Verifies copy real for variational real function by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_Variational_RealFunction, Copy_Integer)

Verifies copy integer for variational real function by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_Variational_RealFunction, ZeroValue)

Verifies zero value for variational real function by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealFunction, NegativeValue)

Verifies negative value for variational real function by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealFunction, ConstantFunction_TracedToBoundary)

Verifies constant function traced to boundary for variational real function by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealFunction, Callable_UsesIntegrationPointFastPath)

Verifies callable uses integration point fast path for variational real function by checking tolerance-based numerical results.

TEST(Rodin_Variational_RealFunction, Expression_PropagatesIntegrationPointFastPath)

Verifies expression propagates integration point fast path for variational real function by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, RealFunction_Zero)

Verifies real function zero for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, RealFunction_PiOverTwo)

Verifies real function pi over two for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, RealFunction_Pi)

Verifies real function pi for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, RealFunction_ThreePiOverTwo)

Verifies real function three pi over two for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, RealFunction_TwoPi)

Verifies real function two pi for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, RealFunction_PiOverSix)

Verifies real function pi over six for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, RealFunction_PiOverFour)

Verifies real function pi over four for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, RealFunction_PiOverThree)

Verifies real function pi over three for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, RealFunction_NegativeValue)

Verifies real function negative value for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, GridFunction_SinWave)

Verifies grid function sin wave for variational sin by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Sin, ChainedOperations)

Verifies chained operations for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, Periodicity)

Verifies periodicity for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, SinOfSum)

Verifies sin of sum for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, SmallAngle)

Verifies small angle for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, LargeAngle)

Verifies large angle for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, SinSquaredIdentity)

Verifies sin squared identity for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, SinWithMultiplication)

Verifies sin with multiplication for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sin, SinOddFunction)

Verifies sin odd function for variational sin by checking tolerance-based numerical results.

TEST(Rodin_Variational_SparseProblem, Construction)

Verifies construction for variational sparse problem.

TEST(Rodin_Variational_SparseProblem, Assemble)

Verifies assemble for variational sparse problem by checking exact expected values, form assembly.

TEST(Rodin_Variational_SparseProblem, MatrixIsSparse)

Verifies matrix is sparse for variational sparse problem by checking form assembly.

TEST(Rodin_Variational_SparseProblem, StiffnessMatrixIsSymmetric)

Verifies stiffness matrix is symmetric for variational sparse problem by checking tolerance-based numerical results, form assembly.

TEST(Rodin_Variational_SparseProblem, SolvePoisson)

Verifies solve poisson for variational sparse problem by checking true predicates, solver behavior.

TEST(Rodin_Variational_SparseProblem, RHSIsNonZeroWithForcing)

Verifies RHS is non zero with forcing for variational sparse problem by checking true predicates, form assembly.

TEST(Rodin_Variational_Sqrt, RealFunction_PositiveValue)

Verifies real function positive value for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, RealFunction_Zero)

Verifies real function zero for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, RealFunction_One)

Verifies real function one for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, RealFunction_PerfectSquare)

Verifies real function perfect square for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, RealFunction_LargeValue)

Verifies real function large value for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, RealFunction_FractionalValue)

Verifies real function fractional value for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, GridFunction_SquareRoot)

Verifies grid function square root for variational sqrt by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Sqrt, ChainedOperations)

Verifies chained operations for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, NestedSquareRoot)

Verifies nested square root for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, IrrationalSquareRoot)

Verifies irrational square root for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, SmallValue)

Verifies small value for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, VeryLargeValue)

Verifies very large value for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, CombinedWithOtherOperations)

Verifies combined with other operations for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, SqrtOfProduct)

Verifies sqrt of product for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, MathematicalIdentities)

Verifies mathematical identities for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sqrt, EquivalenceToPow)

Verifies equivalence to pow for variational sqrt by checking tolerance-based numerical results.

TEST(Rodin_Variational_P1_SubMesh, FES_Construction)

Verifies FES construction for variational P1 sub mesh by checking exact expected values.

TEST(Rodin_Variational_P1_SubMesh, GridFunction_ProjectConstant)

Verifies grid function project constant for variational P1 sub mesh by checking tolerance-based numerical results.

TEST(Rodin_Variational_P1_SubMesh, GridFunction_ProjectLinear)

Verifies grid function project linear for variational P1 sub mesh by checking tolerance-based numerical results.

TEST(Rodin_Variational_P1_SubMesh, GridFunction_EvaluateAtLocalPoint)

Verifies grid function evaluate at local point for variational P1 sub mesh by checking tolerance-based numerical results.

TEST(Rodin_Variational_P1_SubMesh, GridFunction_EvaluateAtParentPoint_Restriction)

The FES mesh is a SubMesh; we evaluate using a Point whose polytope.

TEST(Rodin_Variational_P1_ParentMesh, GridFunction_EvaluateAtSubMeshPoint_Inclusion)

The FES mesh is the full parent mesh; we evaluate using a Point whose.

TEST(Rodin_Variational_P1_ParentMesh, GridFunction_EvaluateAtBoundarySubMeshPoint_Inclusion)

Skin SubMesh: (d-1)-dimensional boundary of the full 2D mesh.

TEST(Rodin_Variational_P0_SubMesh, FES_Construction)

Verifies FES construction for variational P0 sub mesh by checking exact expected values.

TEST(Rodin_Variational_P0_SubMesh, GridFunction_ProjectConstant)

Verifies grid function project constant for variational P0 sub mesh by checking tolerance-based numerical results.

TEST(Rodin_Variational_P0_SubMesh, GridFunction_ProjectSpatialFunction)

Verifies grid function project spatial function for variational P0 sub mesh by checking tolerance-based numerical results.

TEST(Rodin_Variational_P0_SubMesh, GridFunction_EvaluateAtParentPoint_Restriction)

Verifies grid function evaluate at parent point restriction for variational P0 sub mesh by checking tolerance-based numerical results.

TEST(Rodin_Variational_Vector_P1_SubMesh, FES_Construction)

Verifies FES construction for variational vector P1 sub mesh by checking exact expected values.

TEST(Rodin_Variational_Vector_P1_SubMesh, GridFunction_ProjectVectorConstant)

Verifies grid function project vector constant for variational vector P1 sub mesh by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sum, RealFunction_Addition)

Verifies real function addition for variational sum by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sum, RealFunction_ZeroAddition)

Verifies real function zero addition for variational sum by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sum, RealFunction_NegativeAddition)

Verifies real function negative addition for variational sum by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sum, VectorFunction_Addition)

Verifies vector function addition for variational sum by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sum, VectorFunction_ZeroVector_Addition)

Verifies vector function zero vector addition for variational sum by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sum, GridFunction_Addition)

Verifies grid function addition for variational sum by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Sum, ChainedAddition)

Verifies chained addition for variational sum by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sum, MixedScalarVector_Components)

Verifies mixed scalar vector components for variational sum by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sum, AssociativityTest)

Verifies associativity test for variational sum by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sum, CommutativityTest)

Verifies commutativity test for variational sum by checking tolerance-based numerical results.

TEST(Rodin_Variational_Sum, LargeValueAddition)

Verifies large value addition for variational sum by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, RealFunction_Zero)

Verifies real function zero for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, RealFunction_PiOverFour)

Verifies real function pi over four for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, RealFunction_Pi)

Verifies real function pi for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, RealFunction_MinusPiOverFour)

Verifies real function minus pi over four for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, RealFunction_PiOverSix)

Verifies real function pi over six for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, RealFunction_PiOverThree)

Verifies real function pi over three for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, GridFunction_Tan)

Verifies grid function tan for variational tan by checking tolerance-based numerical results, grid-function projection.

TEST(Rodin_Variational_Tan, ChainedOperations)

Verifies chained operations for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, Periodicity)

Verifies periodicity for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, SmallAngle)

Verifies small angle for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, TanOfSum)

Verifies tan of sum for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, TanOddFunction)

Verifies tan odd function for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, TanSinCosIdentity)

Verifies tan sin cos identity for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, TanWithMultiplication)

Verifies tan with multiplication for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, TanLargeAngle)

Verifies tan large angle for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, TanPositiveNegative)

Verifies tan positive negative for variational tan.

TEST(Rodin_Variational_Tan, TanSecantIdentity)

Verifies tan secant identity for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, TanWithAbs)

Verifies tan with abs for variational tan by checking tolerance-based numerical results.

TEST(Rodin_Variational_Tan, TanSpecialAngles)

Test multiple special angles.

TEST(Rodin_Variational_Tan, TanContinuity)

Test values approaching but not at π/2 where Tan has asymptotes.

TEST(Rodin_Variational_Real_P1_TestFunction, SanityTest_Build)

Verifies sanity test build for variational real P1 test function by checking exact expected values.

TEST(Rodin_Variational_Real_P1_TestFunction, CopyTest)

Verifies copy test for variational real P1 test function by checking exact expected values, copy semantics.

TEST(Rodin_Variational_Real_P1_TestFunction, CopyConstructor)

Verifies copy constructor for variational real P1 test function by checking exact expected values, copy semantics.

TEST(Rodin_Variational_Real_P1_TestFunction, MoveConstructor)

Verifies move constructor for variational real P1 test function by checking exact expected values, move semantics.

TEST(Rodin_Variational_Vector_P1_TestFunction, SanityTest_Build)

Verifies sanity test build for variational vector P1 test function by checking exact expected values.

TEST(Rodin_Variational_Vector_P1_TestFunction, ComponentAccess_2D)

Verifies component access 2 D for variational vector P1 test function.

TEST(Rodin_Variational_Vector_P1_TestFunction, ComponentAccess_3D)

Verifies component access 3 D for variational vector P1 test function.

TEST(Rodin_Variational_Real_P1_TestFunction, GetLeaf)

Verifies get leaf for variational real P1 test function by checking exact expected values.

TEST(Rodin_Variational_Trace, IdentityMatrix_2D)

Trace of the 2x2 identity matrix should be 2.

TEST(Rodin_Variational_Trace, IdentityMatrix_3D)

Trace of the 3x3 identity matrix should be 3.

TEST(Rodin_Variational_Trace, ScaledIdentityMatrix)

Trace of alpha * I should be alpha * n.

TEST(Rodin_Variational_Trace, CopyConstruction)

Verifies copy construction for variational trace by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_Variational_Trace, MoveConstruction)

Verifies move construction for variational trace by checking tolerance-based numerical results, move semantics.

TEST(Rodin_Variational_Trace, PolymorphicCopy)

Verifies polymorphic copy for variational trace by checking tolerance-based numerical results, copy semantics.

TEST(Rodin_Variational_Real_P1_TrialFunction, SanityTest_Build)

Verifies sanity test build for variational real P1 trial function by checking exact expected values.

TEST(Rodin_Variational_Real_P1_TrialFunction, CopyConstructor)

Verifies copy constructor for variational real P1 trial function by checking exact expected values, copy semantics.

TEST(Rodin_Variational_Real_P1_TrialFunction, MoveConstructor)

Verifies move constructor for variational real P1 trial function by checking exact expected values, move semantics.

TEST(Rodin_Variational_Real_P1_TrialFunction, GetSolution)

Verifies get solution for variational real P1 trial function.

TEST(Rodin_Variational_Vector_P1_TrialFunction, SanityTest_Build)

Verifies sanity test build for variational vector P1 trial function by checking exact expected values.

TEST(Rodin_Variational_Vector_P1_TrialFunction, ComponentAccess_2D)

Verifies component access 2 D for variational vector P1 trial function.

TEST(Rodin_Variational_Vector_P1_TrialFunction, ComponentAccess_3D)

Verifies component access 3 D for variational vector P1 trial function.

TEST(Rodin_Variational_Real_P1_TrialFunction, GetLeaf)

Verifies get leaf for variational real P1 trial function by checking exact expected values.

TEST(Rodin_Variational_Vector_P1_TrialFunction, GetSolutionVector)

Verifies get solution vector for variational vector P1 trial function.

TEST(Rodin_Variational_VectorFunction, ConstantVector_2D_Construction)

Verifies constant vector 2 D construction for variational vector function by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_VectorFunction, ConstantVector_3D_Construction)

Verifies constant vector 3 D construction for variational vector function by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_VectorFunction, MixedTypes_Construction)

Verifies mixed types construction for variational vector function by checking tolerance-based numerical results, exact expected values.

TEST(Rodin_Variational_VectorFunction, ComponentAccess_2D)

Verifies component access 2 D for variational vector function by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorFunction, ComponentAccess_3D)

Verifies component access 3 D for variational vector function by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorFunction, IndexAccess)

Verifies index access for variational vector function by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorFunction, CopyConstructor)

Verifies copy constructor for variational vector function by checking tolerance-based numerical results, exact expected values, copy semantics.

TEST(Rodin_Variational_VectorFunction, MoveConstructor)

Verifies move constructor for variational vector function by checking tolerance-based numerical results, exact expected values, move semantics.

TEST(Rodin_Variational_VectorFunction, Copy)

Verifies copy for variational vector function by checking tolerance-based numerical results, exact expected values, copy semantics.

TEST(Rodin_Variational_VectorFunction, TraceToBoundary)

Verifies trace to boundary for variational vector function by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorFunction, ZeroVector)

Verifies zero vector for variational vector function by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorFunction, ComponentCallables_UseIntegrationPointFastPath)

Verifies component callables use integration point fast path for variational vector function by checking tolerance-based numerical results.

TEST(Rodin_Variational_VectorFunction, Callable_UsesIntegrationPointFastPath)

Verifies callable uses integration point fast path for variational vector function by checking tolerance-based numerical results.

Variables

Real EDGE_TOL constexpr

Helper used by the tests to EDGE TOL.

const Real EDGE_EPS

Helper used by the tests to EDGE EPS.

Real FACE_TOL constexpr

Helper used by the tests to FACE TOL.

const Real FACE_EPS

Helper used by the tests to FACE EPS.

int AXIS_X constexpr

Helper used by the tests to AXIS X.

int AXIS_Y constexpr

Helper used by the tests to AXIS Y.

int AXIS_Z constexpr

Helper used by the tests to AXIS Z.

const Geometry::Polytope::Traits pointTraits

Helper used by the tests to Point Traits.

Function documentation

static Mesh<Context::Local> Rodin::Tests::Unit::makeAllGeomMesh(Polytope::Type geom, size_t n = 4)

Creates a mesh with minimal connectivity for cell integration.

For each geometry, computes cell→face incidence (needed for boundary detection by BC assemblers) and cell→vertex incidence (for DOF mapping).

static Mesh<Context::Local> Rodin::Tests::Unit::makeMixed2DMesh()

Helper to build a mixed 2D mesh with triangles and quadrilaterals.

Layout (6 vertices, 3 cells): 2—3—4 |\ | Q | | \ | | 0–1-—5

T0: (0,1,2), T1: (1,3,2), Q0: (1,5,4,3)

static Mesh<Context::Local> Rodin::Tests::Unit::makeMixed3DMesh()

Helper to build a mixed 3D mesh with tetrahedra and wedges.

Tet: (0,1,2,6) Wedge: (0,1,2,3,4,5) — prism extruding the base triangle upward

static Mesh<Context::Local> Rodin::Tests::Unit::makeLargerMixed2DMesh()

Builds a larger mixed 2D mesh: 4 triangles + 2 quadrilaterals.

Layout (8 vertices): 5—6—7 | Q1| Q0| 2—3—4 |\ T1 /| |T0\ /T3| 0—1 |\ T2 (uses vertex 4 from above)

Actually, simpler to just build a strip: 4—5—6—7 |T1/| Q1 | | / | Q0| | 0—1—2—3

Rodin::Tests::Unit::TEST(Rodin_Geometry_Sharder, HDF5_ShardSaveLoad_TopologyRoundTrip)

Verifies that each shard's vertex and cell counts are preserved through an HDF5 save/load round-trip.

Shard inherits from Mesh<Context::Local>, so it can be persisted with the standard local HDF5 printer. After reloading, the base mesh topology (space dimension, topological dimension, vertex count, cell count) must match the original shard exactly.

Rodin::Tests::Unit::TEST(Rodin_Geometry_Sharder, HDF5_ShardSaveLoad_Reconcile_GlobalConsistency)

Verifies global mesh consistency after HDF5 shard save/load.

After reloading each shard from HDF5:

• Vertex coordinates are preserved (geometric reconcile check): for each global vertex ID appearing in multiple shards, all loaded copies carry the same spatial coordinates as in the original shard.
• Owned cell and vertex counts from the original shards sum to the global mesh totals (partition reconcile check).

Rodin::Tests::Unit::TEST_P(LagrangianTest, BasicConstruction)

Test basic Lagrangian class construction.

This test verifies that Lagrangian objects can be constructed with proper trial/test functions, initial conditions, and velocity fields.

Rodin::Tests::Unit::TEST_P(LagrangianTest, DifferentVelocityFields)

Test Lagrangian with different velocity field types.

This test verifies that Lagrangian can work with various velocity fields.

Rodin::Tests::Unit::TEST_P(LagrangianTest, StepFunction)

Test Lagrangian step function basic functionality.

This test verifies that the step function can be called without errors. Note: The current implementation may have template deduction issues, so this test focuses on basic construction.

Rodin::Tests::Unit::TEST_P(LagrangianTest, DifferentInitialConditions)

Test with different initial conditions.

This test verifies that Lagrangian works with various initial conditions.

Rodin::Tests::Unit::TEST(Rodin_MPI_Geometry_Mesh, Reconcile_Faces3D_GlobalOwnershipCount)

Verifies that reconcile(2) on a 3D tetrahedron mesh produces correct global face ownership count.

Uses distributeFromRoot because the MPI UniformGrid for 3D types may produce degenerate partitions with small grids.

Rodin::Tests::Unit::TEST(Rodin_MPI_Geometry_Mesh, Shard_HDF5_SaveLoad_BaseTopologyRoundTrip)

Verifies that each rank's shard can be saved to HDF5 and reloaded with base mesh topology preserved.

Exercises steps 1–3 of the shard HDF5 workflow:

1. Mesh is sharded (distributed via distributeFromRoot).
2. Each rank saves its shard using MeshPrinter<FileFormat::HDF5, Context::MPI>, which writes both the base mesh topology and the /Shard/... metadata datasets.
3. Each rank rereads its shard from HDF5 through the MPI mesh loader.

After reloading, the vertex and cell counts must match the original shard.

Rodin::Tests::Unit::TEST(Rodin_MPI_Geometry_Mesh, Shard_HDF5_FullWorkflow_Reconcile)

Full HDF5 shard workflow: distribute → save → reload → reconcile.

Exercises all four steps of the workflow:

1. Mesh is sharded (distributed via distributeFromRoot).
2. Each rank saves its shard to a per-rank HDF5 file using the MPI printer (writes base mesh + /Shard/... metadata).
3. Each rank rereads its shard from HDF5 through the MPI mesh loader.
4. Edge connectivity is then computed and reconciled.

After reconciliation, the global sum of locally-owned edges must equal the total edge count of the reference mesh.

Rodin::Tests::Unit::TEST(MPIP0FESSubMesh, BoundarySubMesh_GetDOFs_ConsistentWithGetGlobalIndex_Triangle)

getDOFs and getGlobalIndex are consistent for P0 on boundary SubMesh.

For P0 each element has exactly one DOF. getDOFs(D, i)[0] must equal getGlobalIndex({D, i}, 0).

Rodin::Tests::Unit::TEST(MPIP0FESSubMesh, CellSubMesh_OwnedDOFs_GloballyUnique_Triangle)

Owned P0 DOFs on the full-cell SubMesh are globally unique.

Gather all owned DOFs on rank 0 and verify no duplicates appear.

Rodin::Tests::Unit::TEST(MPIP1FESSubMesh, CellSubMesh_OwnedDOFs_GloballyUnique_Triangle)

Owned P1 DOFs on the full-cell SubMesh are globally unique.

Gather all owned DOFs on rank 0 and verify no duplicates appear.

Rodin::Tests::Unit::TEST(MPIP1FESSubMesh, BoundarySubMesh_OwnedDOFs_GloballyUnique_Triangle)

Owned P1 DOFs on boundary SubMesh are globally unique and cover the expected range exactly.

This is a regression test for the MPI tag-collision bug: before the fix, P0 cell SubMesh sends with tag=0 would accumulate and be consumed by a subsequent P1 boundary SubMesh irecv on the same tag, leaving some Shared vertices with invalid DOFs.

Rodin::Tests::Unit::TEST(MPIP1FESSubMesh, Regression_P0CellThenP1Boundary_AllLocalVertices_HaveValidGlobalDOF)

Regression test for MPI message tag collision.

Previously, P0 on a cell SubMesh used tag=0 for its DOF exchange and could leave unmatched sends in the MPI buffer. A subsequent P1 boundary SubMesh construction would irecv on tag=0 and consume those stale P0 messages, corrupting Shared-vertex DOF assignments.

After the fix (symmetric drain, distinct tags), the P1 boundary SubMesh must produce valid DOFs even when constructed after P0 cell and P0 boundary SubMesh spaces.

Rodin::Tests::Unit::TEST(MPIP1FESSubMesh, Regression_OrphanVertex_AllLocalVertices_HaveValidGlobalDOF_Triangle)

Regression test for the SubMesh orphaned-vertex ownership bug.

A vertex v with Shared(owner=A) in the volume partition is added to the boundary SubMesh on ranks B (and possibly C,D,...) when those ranks have boundary faces adjacent to v. If rank A has no boundary face adjacent to v, the SubMesh finalize() 2-round exchange must promote the minimum-rank querier to Owned so that P1 can assign a valid global DOF.

Passing this test requires the 2-round ownership fix in SubMesh::finalize.

Rodin::Tests::Unit::TEST(Rodin_Variational_DirichletBC, IdentificationUnaryMinus)

Verifies that DirichletBC(u, -v) produces coefficient -1.

Mathematical content:

Rodin::Tests::Unit::TEST(Rodin_Variational_DirichletBC, IdentificationSelfDegenerate)

Self-identification DirichletBC(u, u).on(Γ) produces, for each slave DOF on Γ, the same DOF as master with coefficient 1 — a row which is algebraically vacuous (singular slave row) but assembled correctly.

This test only checks the assembled IdentifiedDOFs map; using the BC in a Problem solve would yield a singular system. For periodicity use PeriodicBC with an explicit DOF adjacency map.

Rodin::Tests::Unit::TEST(Rodin_Variational_DirichletBC, IdentificationVectorVector)

Vector-to-vector identification: DirichletBC(u_vec, v_vec).

Both u and v are vector P1 trial functions on the same vector FES. The slave/master DOFs share the same global indices (same FES) and each master appears exactly once with coefficient 1.

Rodin::Tests::Unit::TEST_P(FlowTest, BasicConstruction)

Test basic Flow class construction and coordinate handling.

This test verifies that Flow objects can be constructed with valid velocity fields and that basic coordinate system handling works.

Rodin::Tests::Unit::TEST_P(FlowTest, VelocityFieldEvaluation)

Test different velocity field types and their evaluation.

This test verifies that different types of velocity fields can be properly constructed and evaluated at specific points.

Rodin::Tests::Unit::TEST_P(FlowTest, MeshAccess)

Test mesh polytope access and validation.

This test verifies basic mesh functionality needed for Flow operations.

std::tuple<Real, Real, Real> Rodin::Tests::Unit::computeTriangleFaceBarycentric(Real px, Real py, Real pz, Real x0, Real y0, Real z0, Real x1, Real y1, Real z1, Real x2, Real y2, Real z2)

Checks if a 3D point lies on a triangular face and computes its barycentric coordinates.

Parameters
px	The query point coordinates
py	The query point coordinates
pz	The query point coordinates
x0	First vertex of the triangle (corresponds to barycentric u=1)
y0	First vertex of the triangle (corresponds to barycentric u=1)
z0	First vertex of the triangle (corresponds to barycentric u=1)
x1	Second vertex of the triangle (corresponds to barycentric v=1)
y1	Second vertex of the triangle (corresponds to barycentric v=1)
z1	Second vertex of the triangle (corresponds to barycentric v=1)
x2	Third vertex of the triangle (corresponds to barycentric w=1)
y2	Third vertex of the triangle (corresponds to barycentric w=1)
z2	Third vertex of the triangle (corresponds to barycentric w=1)
Returns	Tuple of (u, v, w) barycentric coordinates if point is on face; (NaN, NaN, NaN) if point is not on the triangular face

Uses the barycentric coordinate method to determine if point (px, py, pz) lies on the triangle defined by vertices (x0,y0,z0), (x1,y1,z1), (x2,y2,z2).

Algorithm:

1. Express the point as P = u*V0 + v*(V1-V0) + w*(V2-V0) where u + v + w = 1
2. Solve for v, w using dot products (Cramer's rule)
3. Point is on triangle if 0 <= u,v,w <= 1 and point lies on the plane

std::pair<Real, Real> Rodin::Tests::Unit::computeQuadFaceParametric(Real px, Real py, Real pz, Real x0, Real y0, Real z0, Real x1, Real y1, Real z1, Real x2, Real y2, Real z2, Real x3, Real y3, Real z3)

Checks if a 3D point lies on a planar quadrilateral face and computes parametric coords.

Parameters
px	The query point coordinates
py	The query point coordinates
pz	The query point coordinates
x0	First vertex (maps to parametric (0,0))
y0	First vertex (maps to parametric (0,0))
z0	First vertex (maps to parametric (0,0))
x1	Second vertex (maps to parametric (1,0))
y1	Second vertex (maps to parametric (1,0))
z1	Second vertex (maps to parametric (1,0))
x2	Third vertex (maps to parametric (1,1))
y2	Third vertex (maps to parametric (1,1))
z2	Third vertex (maps to parametric (1,1))
x3	Fourth vertex (maps to parametric (0,1))
y3	Fourth vertex (maps to parametric (0,1))
z3	Fourth vertex (maps to parametric (0,1))
Returns	Pair of (s, t) parametric coordinates if point is on face; (NaN, NaN) if point is not on the quadrilateral face

For a planar quadrilateral with vertices ordered counter-clockwise, determines if point (px, py, pz) lies on the face and computes its parametric coordinates (s, t) in [0,1]x[0,1].

Algorithm:

1. Compute the face normal using cross product of edge vectors
2. Check if point lies on the plane within tolerance
3. Project to 2D by dropping the axis with largest normal component
4. Solve for parametric coordinates in the projected space

Note: This simplified algorithm assumes axis-aligned or near-axis-aligned quads, which is appropriate for reference element faces.

std::pair<bool, Geometry::Point> Rodin::Tests::Unit::findInteriorFacePoint(Geometry::Mesh<Context::Local>& mesh)

Finds an interior face in the mesh and returns a point at its midpoint.

Parameters
mesh in	The mesh (face-to-cell connectivity will be computed)
Returns	A pair: (true, Point on interior face) or (false, dummy Point)

Rodin::Tests::Unit::TEST(MixedProblem_PreassembledBF, SparseP0P1_MatrixMatchesIntegralOnly)

Mixed P0/P1 problem: compare integral-only vs preassembled BF.

System: Integral(u, v) – Integral(p, v) = 0 (test v in P1) Integral(p, q) = (f, q) (test q in P0)

We replace the Integral(p, q) block with a preassembled BilinearForm and verify the global matrix matches.

Rodin::Tests::Unit::TEST(Rodin_Variational_Real_P1_TrialFunction, FuzzyTest_UniformGrid_4x4)

Verifies fuzzy test uniform grid 4 x 4 for variational real P1 trial function.

Verifies fuzzy test uniform grid 4 x 4 for variational real P1 trial function by checking exact expected values.

Rodin::Tests::Unit::TEST(Rodin_Variational_Real_P1_TestFunction, FuzzyTest_UniformGrid_4x4)

Verifies fuzzy test uniform grid 4 x 4 for variational real P1 test function.

Verifies fuzzy test uniform grid 4 x 4 for variational real P1 test function by checking exact expected values.

Rodin::Tests::Unit::TEST(Rodin_Variational_P1_SubMesh, FES_Construction)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Verifies FES construction for variational P1 sub mesh by checking exact expected values.

Rodin::Tests::Unit::TEST(Rodin_Variational_P1_SubMesh, GridFunction_ProjectConstant)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Verifies grid function project constant for variational P1 sub mesh by checking tolerance-based numerical results.

Rodin::Tests::Unit::TEST(Rodin_Variational_P1_SubMesh, GridFunction_ProjectLinear)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Verifies grid function project linear for variational P1 sub mesh by checking tolerance-based numerical results.

Rodin::Tests::Unit::TEST(Rodin_Variational_P1_SubMesh, GridFunction_EvaluateAtLocalPoint)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Verifies grid function evaluate at local point for variational P1 sub mesh by checking tolerance-based numerical results.

Rodin::Tests::Unit::TEST(Rodin_Variational_P1_SubMesh, GridFunction_EvaluateAtParentPoint_Restriction)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

The FES mesh is a SubMesh; we evaluate using a Point whose polytope.

Rodin::Tests::Unit::TEST(Rodin_Variational_P1_ParentMesh, GridFunction_EvaluateAtSubMeshPoint_Inclusion)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

The FES mesh is the full parent mesh; we evaluate using a Point whose.

Rodin::Tests::Unit::TEST(Rodin_Variational_P1_ParentMesh, GridFunction_EvaluateAtBoundarySubMeshPoint_Inclusion)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Skin SubMesh: (d-1)-dimensional boundary of the full 2D mesh.

Rodin::Tests::Unit::TEST(Rodin_Variational_P0_SubMesh, FES_Construction)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Verifies FES construction for variational P0 sub mesh by checking exact expected values.

Rodin::Tests::Unit::TEST(Rodin_Variational_P0_SubMesh, GridFunction_ProjectConstant)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Verifies grid function project constant for variational P0 sub mesh by checking tolerance-based numerical results.

Rodin::Tests::Unit::TEST(Rodin_Variational_P0_SubMesh, GridFunction_ProjectSpatialFunction)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Verifies grid function project spatial function for variational P0 sub mesh by checking tolerance-based numerical results.

Rodin::Tests::Unit::TEST(Rodin_Variational_P0_SubMesh, GridFunction_EvaluateAtParentPoint_Restriction)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Verifies grid function evaluate at parent point restriction for variational P0 sub mesh by checking tolerance-based numerical results.

Rodin::Tests::Unit::TEST(Rodin_Variational_Vector_P1_SubMesh, FES_Construction)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Verifies FES construction for variational vector P1 sub mesh by checking exact expected values.

Rodin::Tests::Unit::TEST(Rodin_Variational_Vector_P1_SubMesh, GridFunction_ProjectVectorConstant)

#include </home/runner/work/rodin/rodin/tests/unit/Rodin/Variational/SubMeshGridFunctionTest.cpp>

Verifies grid function project vector constant for variational vector P1 sub mesh by checking tolerance-based numerical results.