diff --git a/Sofa/Component/StateContainer/tests/CMakeLists.txt b/Sofa/Component/StateContainer/tests/CMakeLists.txt index 14059938bf1..970fa4e6382 100644 --- a/Sofa/Component/StateContainer/tests/CMakeLists.txt +++ b/Sofa/Component/StateContainer/tests/CMakeLists.txt @@ -4,6 +4,7 @@ project(Sofa.Component.StateContainer_test) set(SOURCE_FILES MechanicalObject_test.cpp + MechanicalObjectVOp_test.cpp ) add_executable(${PROJECT_NAME} ${SOURCE_FILES}) diff --git a/Sofa/Component/StateContainer/tests/MechanicalObjectVOp_test.cpp b/Sofa/Component/StateContainer/tests/MechanicalObjectVOp_test.cpp new file mode 100644 index 00000000000..b1ca88edc2a --- /dev/null +++ b/Sofa/Component/StateContainer/tests/MechanicalObjectVOp_test.cpp @@ -0,0 +1,810 @@ +/****************************************************************************** +* SOFA, Simulation Open-Framework Architecture * +* (c) 2006 INRIA, USTL, UJF, CNRS, MGH * +* * +* This program is free software; you can redistribute it and/or modify it * +* under the terms of the GNU Lesser General Public License as published by * +* the Free Software Foundation; either version 2.1 of the License, or (at * +* your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, but WITHOUT * +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License * +* for more details. * +* * +* You should have received a copy of the GNU Lesser General Public License * +* along with this program. If not, see . * +******************************************************************************* +* Authors: The SOFA Team and external contributors (see Authors.txt) * +* * +* Contact information: contact@sofa-framework.org * +******************************************************************************/ +#include +#include + +namespace sofa +{ + +template +struct MechanicalObjectVOpTest : public testing::BaseTest +{ + using MO = component::statecontainer::MechanicalObject; + + static constexpr Real_t positionCoefficient = 19; + static constexpr Real_t restPositionCoefficient = 20; + static constexpr Real_t freePositionCoefficient = 5; + static constexpr Real_t velocityCoefficient = 12; + static constexpr Real_t forceCoefficient = 63; + static constexpr Real_t freeVelocityCoefficient = 78; + + void onSetUp() override + { + m_mechanicalObject = core::objectmodel::New(); + + m_mechanicalObject->x0.forceSet(); + m_mechanicalObject->f.forceSet(); + m_mechanicalObject->xfree.forceSet(); + m_mechanicalObject->vfree.forceSet(); + + m_mechanicalObject->resize(10); + + setVecValues(positionCoefficient); + checkVecValues(positionCoefficient); + + setVecValues(restPositionCoefficient); + checkVecValues(restPositionCoefficient); + + setVecValues(freePositionCoefficient); + checkVecValues(freePositionCoefficient); + + setVecValues(velocityCoefficient); + checkVecValues(velocityCoefficient); + + setVecValues(forceCoefficient); + checkVecValues(forceCoefficient); + + setVecValues(freeVelocityCoefficient); + checkVecValues(freeVelocityCoefficient); + } + + template + void setVecValues(Real_t coefficient = 1) const + { + unsigned int index {}; + auto vec = sofa::helper::getWriteOnlyAccessor(*m_mechanicalObject->write(vtype)); + ASSERT_EQ(vec.size(), 10); + for (auto& v : vec) + { + for (std::size_t i = 0; i < v.size(); ++i) + { + v[i] = static_cast>(index) * coefficient; + } + ++index; + } + } + + template + void checkVecValues(Real_t coefficient = 1) const + { + unsigned int index {}; + auto vec = sofa::helper::getReadAccessor(*m_mechanicalObject->read(vtype)); + ASSERT_EQ(vec.size(), 10); + for (auto& v : vec) + { + for (std::size_t i = 0; i < v.size(); ++i) + { + EXPECT_FLOATINGPOINT_EQ(v[i], static_cast>(index) * coefficient); + } + ++index; + } + } + + template + void checkVecSpatialValues(Real_t coefficient = 1) const + { + unsigned int index {}; + auto vec = sofa::helper::getReadAccessor(*m_mechanicalObject->read(vtype)); + ASSERT_EQ(vec.size(), 10); + for (auto& v : vec) + { + for (std::size_t i = 0; i < DataTypes::spatial_dimensions; ++i) + { + EXPECT_FLOATINGPOINT_EQ(v[i], static_cast>(index) * coefficient); + } + ++index; + } + } + + bool v_null() const + { + //check that an error is emitted + { + EXPECT_MSG_EMIT(Error); + m_mechanicalObject->vOp(nullptr, core::VecId::null()); + } + + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient); + + return true; + } + + void resetPosition() const + { + //check that an error is not emitted + { + EXPECT_MSG_NOEMIT(Error); + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position); + } + + //position is reset + for (auto& position : m_mechanicalObject->readPositions()) + { + static Coord_t defaulConstructedCoord; + for (std::size_t i = 0; i < position.size(); ++i) + { + EXPECT_FLOATINGPOINT_EQ(position[i], defaulConstructedCoord[i]); + } + } + + checkVecValues(velocityCoefficient); + } + + void resetVelocity() const + { + //check that an error is not emitted + { + EXPECT_MSG_NOEMIT(Error); + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity); + } + + //velocity is reset + for (auto& velocity : m_mechanicalObject->readVelocities()) + { + static Deriv_t defaulConstructedDeriv; + for (std::size_t i = 0; i < velocity.size(); ++i) + { + EXPECT_FLOATINGPOINT_EQ(velocity[i], defaulConstructedDeriv[i]); + } + } + + checkVecValues(positionCoefficient); + } + + void multiplyByScalarPosition() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v *= f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::ConstVecId::null(), core::vec_id::read_access::position, 2._sreal); + } + checkVecSpatialValues(positionCoefficient * 2_sreal); + checkVecValues(velocityCoefficient); + } + + void multiplyByScalarVelocity() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v *= f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::ConstVecId::null(), core::vec_id::read_access::velocity, 2._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient * 2_sreal); + } + + void equalOtherMultiplyByScalarPosition() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::ConstVecId::null(), core::vec_id::read_access::restPosition, 2._sreal); + } + checkVecSpatialValues(restPositionCoefficient * 2); + checkVecValues(velocityCoefficient); + } + + void equalOtherMultiplyByScalarVelocity() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::ConstVecId::null(), core::vec_id::read_access::force, 2._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(forceCoefficient * 2); + } + + void equalOtherMultiplyByScalarPositionMix() const + { + { + EXPECT_MSG_EMIT(Error); + //v = b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::ConstVecId::null(), core::vec_id::read_access::velocity, 2._sreal); + } + checkVecSpatialValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalOtherMultiplyByScalarVelocityMix() const + { + { + EXPECT_MSG_EMIT(Error); + //v = b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::ConstVecId::null(), core::vec_id::read_access::position, 2._sreal); + } + checkVecSpatialValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalOtherPosition() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = a + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::restPosition, core::ConstVecId::null(), 1._sreal); + } + checkVecValues(restPositionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalOtherPositionMix() const + { + { + EXPECT_MSG_EMIT(Error); + //v = a + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::velocity, core::ConstVecId::null(), 1._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalOtherVelocity() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = a + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::force, core::ConstVecId::null(), 1._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(forceCoefficient); + } + + void equalOtherVelocityMix() const + { + { + EXPECT_MSG_EMIT(Error); + //v = a + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::restPosition, core::ConstVecId::null(), 1._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void plusEqualOtherPosition() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v += b + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::position, core::vec_id::read_access::restPosition, 1._sreal); + } + checkVecSpatialValues(positionCoefficient + restPositionCoefficient); + checkVecValues(velocityCoefficient); + } + + void plusEqualOtherPositionMix() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v += b + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::position, core::vec_id::read_access::freeVelocity, 1._sreal); + } + checkVecSpatialValues(positionCoefficient + freeVelocityCoefficient); + checkVecValues(velocityCoefficient); + } + + void plusEqualOtherVelocity() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v += b + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::velocity, core::vec_id::read_access::force, 1._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient + forceCoefficient); + } + + void plusEqualOtherVelocityMix() const + { + { + EXPECT_MSG_EMIT(Error); + //v += b + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::velocity, core::vec_id::read_access::position, 1._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void plusEqualOtherMultipliedByScalarPosition() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v += b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::position, core::vec_id::read_access::restPosition, 2._sreal); + } + checkVecSpatialValues(positionCoefficient + restPositionCoefficient * 2); + checkVecValues(velocityCoefficient); + } + + void plusEqualOtherMultipliedByScalarPositionMix() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v += b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::position, core::vec_id::read_access::freeVelocity, 2._sreal); + } + checkVecSpatialValues(positionCoefficient + freeVelocityCoefficient * 2); + checkVecValues(velocityCoefficient); + } + + void plusEqualOtherMultipliedByScalarVelocity() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v += b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::velocity, core::vec_id::read_access::force, 2._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient + forceCoefficient * 2); + } + + void plusEqualOtherMultipliedByScalarVelocityMix() const + { + { + EXPECT_MSG_EMIT(Error); + //v += b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::velocity, core::vec_id::read_access::freePosition, 2._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void plusEqualOtherPosition_2() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v += a + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::restPosition, core::vec_id::read_access::position, 1._sreal); + } + checkVecSpatialValues(positionCoefficient + restPositionCoefficient); + checkVecValues(velocityCoefficient); + } + + void plusEqualOtherPositionMix_2() const + { + { + EXPECT_MSG_EMIT(Error); + //v += a + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::freeVelocity, core::vec_id::read_access::position, 1._sreal); + } + checkVecSpatialValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void plusEqualOtherVelocity_2() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v += a + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::force, core::vec_id::read_access::velocity, 1._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient + forceCoefficient); + } + + void plusEqualOtherVelocityMix_2() const + { + { + EXPECT_MSG_EMIT(Error); + //v += a + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::freePosition, core::vec_id::read_access::velocity, 1._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void multipliedByScalarThenAddOtherPosition() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = a+v*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::restPosition, core::vec_id::read_access::position, 3_sreal); + } + checkVecSpatialValues(restPositionCoefficient + positionCoefficient * 3); + checkVecValues(velocityCoefficient); + } + + void multipliedByScalarThenAddOtherPositionMix() const + { + { + EXPECT_MSG_EMIT(Error); + //v = a+v*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::freeVelocity, core::vec_id::read_access::position, 3_sreal); + } + checkVecSpatialValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void multipliedByScalarThenAddOtherVelocity() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = a+v*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::force, core::vec_id::read_access::velocity, 7._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient * 7 + forceCoefficient); + } + + void multipliedByScalarThenAddOtherVelocityMix() const + { + { + EXPECT_MSG_EMIT(Error); + //v = a+v*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::freePosition, core::vec_id::read_access::velocity, 7._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalSumPosition() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = a+b + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::restPosition, core::vec_id::read_access::freePosition, 1_sreal); + } + checkVecSpatialValues(restPositionCoefficient + freePositionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalSumPositionMix1() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = a+b + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::restPosition, core::vec_id::read_access::freeVelocity, 1_sreal); + } + checkVecSpatialValues(restPositionCoefficient+freeVelocityCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalSumPositionMix2() const + { + { + EXPECT_MSG_EMIT(Error); + //v = a+b + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::freeVelocity, core::vec_id::read_access::freePosition, 1_sreal); + } + checkVecSpatialValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalSumVelocity() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = a+b + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::force, core::vec_id::read_access::freeVelocity, 1._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(forceCoefficient + freeVelocityCoefficient); + } + + void equalSumVelocityMix1() const + { + { + EXPECT_MSG_EMIT(Error); + //v = a+b + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::position, core::vec_id::read_access::freeVelocity, 1._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalSumVelocityMix2() const + { + { + EXPECT_MSG_EMIT(Error); + //v = a+b + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::force, core::vec_id::read_access::position, 1._sreal); + } + checkVecValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalSumWithScalarPosition() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = a+b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::restPosition, core::vec_id::read_access::freePosition, 12_sreal); + } + checkVecSpatialValues(restPositionCoefficient + freePositionCoefficient * 12); + checkVecValues(velocityCoefficient); + } + + void equalSumWithScalarPositionMix1() const + { + { + EXPECT_MSG_EMIT(Error); + //v = a+b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::velocity, core::vec_id::read_access::freePosition, 12_sreal); + } + checkVecSpatialValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalSumWithScalarPositionMix2() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = a+b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::position, core::vec_id::read_access::restPosition, core::vec_id::read_access::freeVelocity, 12_sreal); + } + checkVecSpatialValues(restPositionCoefficient + freeVelocityCoefficient * 12); + checkVecValues(velocityCoefficient); + } + + void equalSumWithScalarVelocity() const + { + { + EXPECT_MSG_NOEMIT(Error); + //v = a+b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::force, core::vec_id::read_access::freeVelocity, 12_sreal); + } + checkVecSpatialValues(positionCoefficient); + checkVecValues(forceCoefficient + freeVelocityCoefficient * 12); + } + + void equalSumWithScalarVelocityMix1() const + { + { + EXPECT_MSG_EMIT(Error); + //v = a+b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::position, core::vec_id::read_access::freeVelocity, 12_sreal); + } + checkVecSpatialValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + void equalSumWithScalarVelocityMix2() const + { + { + EXPECT_MSG_EMIT(Error); + //v = a+b*f + m_mechanicalObject->vOp(nullptr, core::vec_id::write_access::velocity, core::vec_id::read_access::force, core::vec_id::read_access::position, 12_sreal); + } + checkVecSpatialValues(positionCoefficient); + checkVecValues(velocityCoefficient); + } + + typename MO::SPtr m_mechanicalObject; +}; + +typedef ::testing::Types< + defaulttype::Vec1Types, + defaulttype::Vec2Types, + defaulttype::Vec3Types, + defaulttype::Rigid2Types, + defaulttype::Rigid3Types +> DataTypesList; + +TYPED_TEST_SUITE(MechanicalObjectVOpTest, DataTypesList); + +TYPED_TEST(MechanicalObjectVOpTest, v_null) +{ + EXPECT_TRUE(this->v_null()); +} + +TYPED_TEST(MechanicalObjectVOpTest, resetPosition) +{ + this->resetPosition(); +} + +TYPED_TEST(MechanicalObjectVOpTest, resetVelocity) +{ + this->resetVelocity(); +} + +TYPED_TEST(MechanicalObjectVOpTest, multiplyByScalarPosition) +{ + this->multiplyByScalarPosition(); +} + +TYPED_TEST(MechanicalObjectVOpTest, multiplyByScalarVelocity) +{ + this->multiplyByScalarVelocity(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalOtherMultiplyByScalarPosition) +{ + this->equalOtherMultiplyByScalarPosition(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalOtherMultiplyByScalarVelocity) +{ + this->equalOtherMultiplyByScalarVelocity(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalOtherMultiplyByScalarPositionMix) +{ + this->equalOtherMultiplyByScalarPositionMix(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalOtherMultiplyByScalarVelocityMix) +{ + this->equalOtherMultiplyByScalarVelocityMix(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalOtherPosition) +{ + this->equalOtherPosition(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalOtherPositionMix) +{ + this->equalOtherPositionMix(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalOtherVelocity) +{ + this->equalOtherVelocity(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalOtherVelocityMix) +{ + this->equalOtherVelocityMix(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherPosition) +{ + this->plusEqualOtherPosition(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherPositionMix) +{ + this->plusEqualOtherPositionMix(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherVelocity) +{ + this->plusEqualOtherVelocity(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherVelocityMix) +{ + this->plusEqualOtherVelocityMix(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherMultipliedByScalarPosition) +{ + this->plusEqualOtherMultipliedByScalarPosition(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherMultipliedByScalarPositionMix) +{ + this->plusEqualOtherMultipliedByScalarPositionMix(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherMultipliedByScalarVelocity) +{ + this->plusEqualOtherMultipliedByScalarVelocity(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherMultipliedByScalarVelocityMix) +{ + this->plusEqualOtherMultipliedByScalarVelocityMix(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherPosition_2) +{ + this->plusEqualOtherPosition_2(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherPositionMix_2) +{ + this->plusEqualOtherPositionMix_2(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherVelocity_2) +{ + this->plusEqualOtherVelocity_2(); +} + +TYPED_TEST(MechanicalObjectVOpTest, plusEqualOtherVelocityMix_2) +{ + this->plusEqualOtherVelocityMix_2(); +} + +TYPED_TEST(MechanicalObjectVOpTest, multipliedByScalarThenAddOtherPosition) +{ + this->multipliedByScalarThenAddOtherPosition(); +} + +TYPED_TEST(MechanicalObjectVOpTest, multipliedByScalarThenAddOtherPositionMix) +{ + this->multipliedByScalarThenAddOtherPositionMix(); +} + +TYPED_TEST(MechanicalObjectVOpTest, multipliedByScalarThenAddOtherVelocity) +{ + this->multipliedByScalarThenAddOtherVelocity(); +} + +TYPED_TEST(MechanicalObjectVOpTest, multipliedByScalarThenAddOtherVelocityMix) +{ + this->multipliedByScalarThenAddOtherVelocityMix(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumPosition) +{ + this->equalSumPosition(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumPositionMix1) +{ + this->equalSumPositionMix1(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumPositionMix2) +{ + this->equalSumPositionMix2(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumVelocity) +{ + this->equalSumVelocity(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumVelocityMix1) +{ + this->equalSumVelocityMix1(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumVelocityMix2) +{ + this->equalSumVelocityMix2(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumWithScalarPosition) +{ + this->equalSumWithScalarPosition(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumWithScalarPositionMix1) +{ + this->equalSumWithScalarPositionMix1(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumWithScalarPositionMix2) +{ + this->equalSumWithScalarPositionMix2(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumWithScalarVelocity) +{ + this->equalSumWithScalarVelocity(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumWithScalarVelocityMix1) +{ + this->equalSumWithScalarVelocityMix1(); +} + +TYPED_TEST(MechanicalObjectVOpTest, equalSumWithScalarVelocityMix2) +{ + this->equalSumWithScalarVelocityMix2(); +} + +} \ No newline at end of file