PorousFlowDictatorTest.C File Reference

Go to the source code of this file.

Functions
	TEST_F (PorousFlowDictatorTest, numVariables)
	TEST_F (PorousFlowDictatorTest, numPhases)
	TEST_F (PorousFlowDictatorTest, numComponents)
	TEST_F (PorousFlowDictatorTest, numAqueousEquilibrium)
	TEST_F (PorousFlowDictatorTest, numAqueousKinetic)
	TEST_F (PorousFlowDictatorTest, aqueousPhaseNumber)
	TEST_F (PorousFlowDictatorTest, porousFlowVariableNum)
	TEST_F (PorousFlowDictatorTest, mooseVariableNum)
	TEST_F (PorousFlowDictatorTest, isPorousFlowVariable)
	TEST_F (PorousFlowDictatorTest, notPorousFlowVariable)
	TEST_F (PorousFlowDictatorTest, consistentFEType)
	TEST_F (PorousFlowDictatorTest, feType)
	TEST_F (PorousFlowDictatorTest, coupleAux)
	TEST_F (PorousFlowDictatorTest, largeAqueousPhase)

Function Documentation

TEST_F() [1/14]

TEST_F	(	PorousFlowDictatorTest	,
		aqueousPhaseNumber
	)

Definition at line 42 of file PorousFlowDictatorTest.C.

{
  EXPECT_EQ(_dictator->aqueousPhaseNumber(), (unsigned int)1);
  EXPECT_EQ(_dictator_no_fetype->aqueousPhaseNumber(), (unsigned int)0);
}

TEST_F() [2/14]

TEST_F	(	PorousFlowDictatorTest	,
		consistentFEType
	)

Definition at line 155 of file PorousFlowDictatorTest.C.

{
  ASSERT_TRUE(_dictator->consistentFEType());
  ASSERT_TRUE(!_dictator_no_fetype->consistentFEType());
}

TEST_F() [3/14]

TEST_F	(	PorousFlowDictatorTest	,
		coupleAux
	)

Definition at line 169 of file PorousFlowDictatorTest.C.

{
  try
  {
    InputParameters params = _factory.getValidParams("PorousFlowDictator");
    params.set<std::vector<VariableName>>("porous_flow_vars") =
        std::vector<VariableName>{"var3", "aux_var", "var0", "var5"};
    params.set<unsigned>("number_fluid_phases") = 1;
    params.set<unsigned>("number_fluid_components") = 2;
    _fe_problem->addUserObject("PorousFlowDictator", "dictator_with_aux", params);
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos =
        std::string(err.what())
            .find(
                "PorousFlowDictator: AuxVariables variables must not be coupled into the Dictator "
                "for this is against specification #1984.  Variable 'aux_var' is either an "
                "AuxVariable or from a different nonlinear system.");
    ASSERT_TRUE(pos != std::string::npos);
  }
}

TEST_F() [4/14]

TEST_F	(	PorousFlowDictatorTest	,
		feType
	)

Definition at line 161 of file PorousFlowDictatorTest.C.

{
  auto linear_lagrange = FEType(Utility::string_to_enum<Order>("FIRST"),
                                Utility::string_to_enum<FEFamily>("LAGRANGE"));
 
  ASSERT_EQ(_dictator->feType(), linear_lagrange);
}

TEST_F() [5/14]

TEST_F	(	PorousFlowDictatorTest	,
		isPorousFlowVariable
	)

Definition at line 133 of file PorousFlowDictatorTest.C.

{
  ASSERT_TRUE(!_dictator->isPorousFlowVariable(0));
  ASSERT_TRUE(_dictator->isPorousFlowVariable(1));
  ASSERT_TRUE(!_dictator->isPorousFlowVariable(2));
  ASSERT_TRUE(_dictator->isPorousFlowVariable(3));
  ASSERT_TRUE(_dictator->isPorousFlowVariable(4));
  ASSERT_TRUE(!_dictator->isPorousFlowVariable(5));
  ASSERT_TRUE(!_dictator->isPorousFlowVariable(123));
}

TEST_F() [6/14]

TEST_F	(	PorousFlowDictatorTest	,
		largeAqueousPhase
	)

Definition at line 193 of file PorousFlowDictatorTest.C.

{
  try
  {
    InputParameters params = _factory.getValidParams("PorousFlowDictator");
    params.set<std::vector<VariableName>>("porous_flow_vars") = std::vector<VariableName>{"var0"};
    params.set<unsigned>("number_fluid_phases") = 1;
    params.set<unsigned>("number_fluid_components") = 2;
    params.set<unsigned>("aqueous_phase_number") = 1;
    _fe_problem->addUserObject(
        "PorousFlowDictator", "dictator_with_large_aqueous_phase_number", params);
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos =
        std::string(err.what())
            .find("PorousflowDictator: The aqueous phase number must be less than the number of "
                  "fluid phases.  The Dictator does not appreciate jokes.");
    ASSERT_TRUE(pos != std::string::npos);
  }
}

TEST_F() [7/14]

TEST_F	(	PorousFlowDictatorTest	,
		mooseVariableNum
	)

Definition at line 110 of file PorousFlowDictatorTest.C.

{
  EXPECT_EQ(_dictator->mooseVariableNum(0), (unsigned int)1);
  EXPECT_EQ(_dictator->mooseVariableNum(1), (unsigned int)4);
  EXPECT_EQ(_dictator->mooseVariableNum(2), (unsigned int)3);
 
  try
  {
    _dictator->mooseVariableNum(3);
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what())
                          .find("The Dictator proclaims that there is no such PorousFlow variable "
                                "with number 3.  Exiting with error code 1984.");
    ASSERT_TRUE(pos != std::string::npos);
  }
 
  EXPECT_EQ(_dictator_no_fetype->mooseVariableNum(0), (unsigned int)1);
  EXPECT_EQ(_dictator_no_fetype->mooseVariableNum(1), (unsigned int)6);
}

TEST_F() [8/14]

TEST_F	(	PorousFlowDictatorTest	,
		notPorousFlowVariable
	)

Definition at line 144 of file PorousFlowDictatorTest.C.

{
  ASSERT_TRUE(_dictator->notPorousFlowVariable(0));
  ASSERT_TRUE(!_dictator->notPorousFlowVariable(1));
  ASSERT_TRUE(_dictator->notPorousFlowVariable(2));
  ASSERT_TRUE(!_dictator->notPorousFlowVariable(3));
  ASSERT_TRUE(!_dictator->notPorousFlowVariable(4));
  ASSERT_TRUE(_dictator->notPorousFlowVariable(5));
  ASSERT_TRUE(_dictator->notPorousFlowVariable(123));
}

TEST_F() [9/14]

TEST_F	(	PorousFlowDictatorTest	,
		numAqueousEquilibrium
	)

Definition at line 30 of file PorousFlowDictatorTest.C.

{
  EXPECT_EQ(_dictator->numAqueousEquilibrium(), (unsigned int)5);
  EXPECT_EQ(_dictator_no_fetype->numAqueousEquilibrium(), (unsigned int)0);
}

TEST_F() [10/14]

TEST_F	(	PorousFlowDictatorTest	,
		numAqueousKinetic
	)

Definition at line 36 of file PorousFlowDictatorTest.C.

{
  EXPECT_EQ(_dictator->numAqueousKinetic(), (unsigned int)6);
  EXPECT_EQ(_dictator_no_fetype->numAqueousKinetic(), (unsigned int)0);
}

TEST_F() [11/14]

TEST_F	(	PorousFlowDictatorTest	,
		numComponents
	)

Definition at line 24 of file PorousFlowDictatorTest.C.

{
  EXPECT_EQ(_dictator->numComponents(), (unsigned int)4);
  EXPECT_EQ(_dictator_no_fetype->numComponents(), (unsigned int)3);
}

TEST_F() [12/14]

TEST_F	(	PorousFlowDictatorTest	,
		numPhases
	)

Definition at line 18 of file PorousFlowDictatorTest.C.

{
  EXPECT_EQ(_dictator->numPhases(), (unsigned int)2);
  EXPECT_EQ(_dictator_no_fetype->numPhases(), (unsigned int)1);
}

TEST_F() [13/14]

TEST_F	(	PorousFlowDictatorTest	,
		numVariables
	)

Definition at line 12 of file PorousFlowDictatorTest.C.

{
  EXPECT_EQ(_dictator->numVariables(), (unsigned int)3);
  EXPECT_EQ(_dictator_no_fetype->numVariables(), (unsigned int)2);
}

TEST_F() [14/14]

TEST_F	(	PorousFlowDictatorTest	,
		porousFlowVariableNum
	)

Definition at line 48 of file PorousFlowDictatorTest.C.

{
  EXPECT_EQ(_dictator->porousFlowVariableNum(1), (unsigned int)0);
  EXPECT_EQ(_dictator->porousFlowVariableNum(4), (unsigned int)1);
  EXPECT_EQ(_dictator->porousFlowVariableNum(3), (unsigned int)2);
 
  try
  {
    _dictator->porousFlowVariableNum(0);
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what())
                          .find("The Dictator proclaims that the moose variable with number 0 is "
                                "not a PorousFlow variable.  Exiting with error code 1984.");
    ASSERT_TRUE(pos != std::string::npos);
  }
 
  try
  {
    _dictator->porousFlowVariableNum(2);
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what())
                          .find("The Dictator proclaims that the moose variable with number 2 is "
                                "not a PorousFlow variable.  Exiting with error code 1984.");
    ASSERT_TRUE(pos != std::string::npos);
  }
 
  try
  {
    _dictator->porousFlowVariableNum(5);
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what())
                          .find("The Dictator proclaims that the moose variable with number 5 is "
                                "not a PorousFlow variable.  Exiting with error code 1984.");
    ASSERT_TRUE(pos != std::string::npos);
  }
 
  try
  {
    _dictator->porousFlowVariableNum(123);
    FAIL();
  }
  catch (const std::exception & err)
  {
    std::size_t pos = std::string(err.what())
                          .find("The Dictator proclaims that the moose variable with number 123 is "
                                "not a PorousFlow variable.  Exiting with error code 1984.");
    ASSERT_TRUE(pos != std::string::npos);
  }
 
  EXPECT_EQ(_dictator_no_fetype->porousFlowVariableNum(1), (unsigned int)0);
  EXPECT_EQ(_dictator_no_fetype->porousFlowVariableNum(6), (unsigned int)1);
}