MooseObjectUnitTest Class Reference

Base class for building basic unit tests for MOOSE objects that can live alone (like user objects, etc.) More...

#include <MooseObjectUnitTest.h>

Inheritance diagram for MooseObjectUnitTest:

Public Member Functions
	MooseObjectUnitTest (const std::string &app_name)

Protected Member Functions
void	buildObjects ()
template<typename T >
T &	addObject (const std::string &type, const std::string &name, InputParameters &params)

Protected Attributes
std::unique_ptr< MooseMesh >	_mesh
std::shared_ptr< MooseApp >	_app
Factory &	_factory
std::shared_ptr< FEProblem >	_fe_problem

Detailed Description

Base class for building basic unit tests for MOOSE objects that can live alone (like user objects, etc.)

This class builds the basic objects that are needed in order to test a MOOSE object. Those are a mesh and an FEProblem. To build a unit test, inherit from this class and build your test using the following template:

In your .h file:

class MyUnitTest : public MooseObjectUnitTest { public: MyUnitTest() : MooseObjectUnitTest("MyAppUnitApp") { // if you are using the old registration system, you want to register your objects using this // call. Otherwise, you do not need it. registerObjects(_factory); buildObjects(); }

protected: void registerObjects(Factory & factory) { // register your objects as usual, we have to be in a method like this so that the register // macros work registerUserObject(MyObjectThatIAmTesting); }

void buildObjects() { // build your object like so InputParameters pars = _factory.getValidParams("MyObjectThatIAmTesting"); _fe_problem->addUserObject("MyObjectThatIAmTesting", "fp", uo_pars); _obj = &_fe_problem->getUserObject<MyObjectThatIAmTesting>("fp"); }

// member variable used later in the actual tests const MyObjectThatIAmTesting * _obj; };

In your .C file

TEST_F(MyObjectThatIAmTesting, test) { EXPECT_EQ("testing", _obj->method(par1, par2)); }

NOTE: Testing mesh-bound objects like Kernels, BCs, etc. is not possible with this class.

Definition at line 69 of file MooseObjectUnitTest.h.

Constructor & Destructor Documentation

MooseObjectUnitTest()

MooseObjectUnitTest::MooseObjectUnitTest ( const std::string &  app_name )

inline

Parameters

app_name

The name of client's application

Definition at line 75 of file MooseObjectUnitTest.h.

    : _app(Moose::createMooseApp(app_name, 0, nullptr)), _factory(_app->getFactory())
  {
    buildObjects();
  }

Member Function Documentation

addObject()

template<typename T >

T & MooseObjectUnitTest::addObject ( const std::string &  type, const std::string &  name, InputParameters &  params  )

protected

Definition at line 114 of file MooseObjectUnitTest.h.

{
  auto objects = _fe_problem->addObject<T>(type, name, params);
  mooseAssert(objects.size() == 1, "Doesn't work with threading");
  return *objects[0];
}

buildObjects()

void MooseObjectUnitTest::buildObjects ( )

inlineprotected

Definition at line 82 of file MooseObjectUnitTest.h.

  {
    InputParameters mesh_params = _factory.getValidParams("GeneratedMesh");
    mesh_params.set<MooseEnum>("dim") = "3";
    mesh_params.set<unsigned int>("nx") = 2;
    mesh_params.set<unsigned int>("ny") = 2;
    mesh_params.set<unsigned int>("nz") = 2;
    _mesh = _factory.createUnique<MooseMesh>("GeneratedMesh", "name1", mesh_params);
    _mesh->setMeshBase(_mesh->buildMeshBaseObject());
    _mesh->buildMesh();
 
    InputParameters problem_params = _factory.getValidParams("FEProblem");
    problem_params.set<MooseMesh *>("mesh") = _mesh.get();
    problem_params.set<std::string>(MooseBase::name_param) = "name2";
    _fe_problem = _factory.create<FEProblem>("FEProblem", "problem", problem_params);
 
    _fe_problem->createQRules(libMesh::QGAUSS, libMesh::FIRST, libMesh::FIRST, libMesh::FIRST);
 
    _app->actionWarehouse().problemBase() = _fe_problem;
  }

Referenced by MooseObjectUnitTest().

Member Data Documentation

_app

std::shared_ptr<MooseApp> MooseObjectUnitTest::_app

protected

Definition at line 107 of file MooseObjectUnitTest.h.

Referenced by buildObjects().

_factory

Factory& MooseObjectUnitTest::_factory

protected

Definition at line 108 of file MooseObjectUnitTest.h.

Referenced by buildObjects().

_fe_problem

std::shared_ptr<FEProblem> MooseObjectUnitTest::_fe_problem

protected

Definition at line 109 of file MooseObjectUnitTest.h.

Referenced by addObject(), and buildObjects().

_mesh

std::unique_ptr<MooseMesh> MooseObjectUnitTest::_mesh

protected

Definition at line 106 of file MooseObjectUnitTest.h.

Referenced by buildObjects().

---

The documentation for this class was generated from the following file:

• include/base/MooseObjectUnitTest.h