anonymous_namespace{testDeckField.cpp} Namespace Reference

Data Structures
struct	SampleDeck
	A deck with one field of each kind the tables have to handle. More...

Functions
void	check (bool ok, const std::string &what)
template<typename Call >
void	checkThrows (Call call, const std::string &contains, const std::string &what)
	Fails unless the call throws with a message containing contains.
void	testDefaultsAndSchema ()
void	testReadAndWrite ()
void	testAccepted ()
void	testKeysAreNamed ()
void	testValuesCheckedWhenBuilt ()
void	testPrint ()
void	testGroups ()
void	testEditDistance ()
void	run (void(*fn)(), const std::string &name)

Variables
int	g_failures = 0
int	g_checks = 0

Function Documentation

check()

void anonymous_namespace{testDeckField.cpp}::check	(	bool	ok,
		const std::string &	what
	)

Definition at line 27 of file testDeckField.cpp.

                                           {
  ++g_checks;
  if (ok)
    return;
  ++g_failures;
  std::cerr << "  FAIL: " << what << "\n";
}

References g_checks, and g_failures.

Referenced by testDefaultsAndSchema(), testEditDistance(), testKeysAreNamed(), testPrint(), testReadAndWrite(), and testValuesCheckedWhenBuilt().

Here is the caller graph for this function:

checkThrows()

template<typename Call >

void anonymous_namespace{testDeckField.cpp}::checkThrows	(	Call	call,
		const std::string &	contains,
		const std::string &	what
	)

Fails unless the call throws with a message containing contains.

Definition at line 37 of file testDeckField.cpp.

                                        {
  ++g_checks;
  try {
    call();
  } catch (const std::exception &e) {
    if (std::string(e.what()).find(contains) != std::string::npos)
      return;
    ++g_failures;
    std::cerr << "  FAIL: " << what << ": message was " << e.what();
    return;
  }
  ++g_failures;
  std::cerr << "  FAIL: " << what << ": nothing was thrown\n";
}

References g_checks, and g_failures.

Referenced by testAccepted(), testGroups(), testKeysAreNamed(), and testValuesCheckedWhenBuilt().

Here is the caller graph for this function:

run()

void anonymous_namespace{testDeckField.cpp}::run	(	void(*)()	fn,
		const std::string &	name
	)

Definition at line 224 of file testDeckField.cpp.

                                              {
  try {
    fn();
  } catch (const std::exception &e) {
    ++g_checks;
    ++g_failures;
    std::cerr << "  FAIL: " << name << " threw: " << e.what() << "\n";
  }
}

References g_checks, and g_failures.

testAccepted()

void anonymous_namespace{testDeckField.cpp}::testAccepted

(

)

Definition at line 119 of file testDeckField.cpp.

                    {
  std::cout << "accepted values and bounds\n";
  SampleDeck d;
  checkThrows(
      [&] {
        inp::readFields(d, json{{"Method", "backward_euler"}},
                        SampleDeck::fields());
      },
      "must be one of", "a value outside the accepted set is rejected");
  checkThrows(
      [&] {
        inp::readFields(d, json{{"Count", 7}}, SampleDeck::fields());
      },
      "must be at most", "a value above the upper bound is rejected");
  checkThrows(
      [&] {
        inp::readFields(d, json{{"Count", 0}}, SampleDeck::fields());
      },
      "must be at least", "a value below the lower bound is rejected");
}

References checkThrows(), anonymous_namespace{testDeckField.cpp}::SampleDeck::fields(), and inp::readFields().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testDefaultsAndSchema()

void anonymous_namespace{testDeckField.cpp}::testDefaultsAndSchema

(

)

Definition at line 80 of file testDeckField.cpp.

                             {
  std::cout << "defaults and schema\n";
  const json d = inp::defaultsJson(SampleDeck::fields());
  check(d.at("Count") == 2, "Count default is written");
  check(d.at("Method") == "central_difference", "Method default is written");
  check(d.find("Optional") == d.end(),
        "a field whose emit condition is false is absent");
 
  const json s = inp::schemaJson(SampleDeck::fields());
  check(s.size() == 5, "schema reports one entry per field");
  check(s.at(0).at("key") == "Count", "schema reports the key");
  check(s.at(0).at("type") == "size_t", "schema reports the type");
  check(s.at(0).at("default") == 2, "schema reports the default");
  check(s.at(0).at("doc") == "How many of them", "schema reports the doc");
  check(s.at(4).find("default") == s.at(4).end(),
        "schema omits the default of a field that is not written");
}

References check(), inp::defaultsJson(), anonymous_namespace{testDeckField.cpp}::SampleDeck::fields(), and inp::schemaJson().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testEditDistance()

void anonymous_namespace{testDeckField.cpp}::testEditDistance

(

)

Definition at line 217 of file testDeckField.cpp.

                        {
  std::cout << "edit distance\n";
  check(inp::editDistance("Count", "Count") == 0, "equal strings");
  check(inp::editDistance("Coun", "Count") == 1, "one deletion");
  check(inp::editDistance("", "abc") == 3, "an empty string");
}

References check(), and inp::editDistance().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testGroups()

void anonymous_namespace{testDeckField.cpp}::testGroups

(

)

Definition at line 194 of file testDeckField.cpp.

                  {
  std::cout << "quantities given in more than one way\n";
  const std::vector<inp::OneOf> groups = {
      {"the horizon", {"Horizon", "Horizon_Mesh_Ratio"}},
      {"the contact stiffness", {"Kn", "V_Max"}, false},
  };
 
  inp::checkGroups(json{{"Horizon", 6.0e-4}, {"Kn", 1.0e12}}, groups);
  // The second group is not required, so leaving it out is accepted.
  inp::checkGroups(json{{"Horizon_Mesh_Ratio", 3.0}}, groups);
 
  checkThrows([&] { inp::checkGroups(json{{"Kn", 1.0e12}}, groups); },
              "None was given",
              "a required group with neither key is rejected");
  checkThrows(
      [&] {
        inp::checkGroups(
            json{{"Horizon", 6.0e-4}, {"Horizon_Mesh_Ratio", 3.0}}, groups);
      },
      "These were given: Horizon Horizon_Mesh_Ratio",
      "a group with both keys is rejected and names them");
}

References inp::checkGroups(), and checkThrows().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testKeysAreNamed()

void anonymous_namespace{testDeckField.cpp}::testKeysAreNamed

(

)

Definition at line 140 of file testDeckField.cpp.

                        {
  std::cout << "keys are named and checked\n";
  checkThrows([] { inp::applyGiven(json{{"Coun", 3}}, SampleDeck::fields()); },
              "Closest declared field is Count",
              "a misspelled key names the closest field");
  checkThrows([] { inp::applyGiven(json{{"Horizon", 1.}}, SampleDeck::fields()); },
              "no field named Horizon", "an unrelated key is rejected");
  checkThrows([] { inp::applyGiven(json{1, 2, 3}, SampleDeck::fields()); },
              "name and value pairs",
              "a list of values without names is rejected");
 
  // A key the deck reads outside the table is accepted when declared.
  json j = inp::applyGiven(json{{"Nested", json::object()}},
                           SampleDeck::fields(), {"Nested"});
  check(j.find("Nested") != j.end(), "a key named in extra is kept");
}

References inp::applyGiven(), check(), checkThrows(), and anonymous_namespace{testDeckField.cpp}::SampleDeck::fields().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testPrint()

void anonymous_namespace{testDeckField.cpp}::testPrint

(

)

Definition at line 182 of file testDeckField.cpp.

                 {
  std::cout << "printed form\n";
  SampleDeck d;
  std::ostringstream oss;
  inp::printFields(d, oss, SampleDeck::fields(), "  ");
  const std::string s = oss.str();
  check(s.find("  Count = 2") != std::string::npos,
        "the printed form has Count after the tab prefix");
  check(s.find("  Method = central_difference") != std::string::npos,
        "the printed form has Method after the tab prefix");
}

References check(), anonymous_namespace{testDeckField.cpp}::SampleDeck::fields(), and inp::printFields().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testReadAndWrite()

void anonymous_namespace{testDeckField.cpp}::testReadAndWrite

(

)

Definition at line 98 of file testDeckField.cpp.

                        {
  std::cout << "read and write\n";
  json j = inp::applyGiven(json{{"Count", 3}, {"Length", 2.25}},
                           SampleDeck::fields());
  SampleDeck d;
  inp::readFields(d, j, SampleDeck::fields());
  check(d.d_count == 3, "Count is read");
  check(d.d_length == 2.25, "Length is read");
  check(d.d_method == "central_difference", "Method keeps its default");
  check(d.d_write, "Write keeps its default");
 
  json out = json::object();
  inp::writeFields(d, out, SampleDeck::fields());
  check(out == j, "writing what was read gives the block back");
 
  // A block with no keys leaves every member at its default.
  SampleDeck empty;
  inp::readFields(empty, json::object(), SampleDeck::fields());
  check(empty.d_count == 2, "an absent key leaves the default");
}

References inp::applyGiven(), check(), anonymous_namespace{testDeckField.cpp}::SampleDeck::d_count, anonymous_namespace{testDeckField.cpp}::SampleDeck::fields(), inp::readFields(), and inp::writeFields().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

testValuesCheckedWhenBuilt()

void anonymous_namespace{testDeckField.cpp}::testValuesCheckedWhenBuilt

(

)

Definition at line 157 of file testDeckField.cpp.

                                  {
  std::cout << "values are checked when a deck is built\n";
  // A deck is rejected where it is built, not only where it is read.
  checkThrows([] { inp::applyGiven(json{{"Count", 9}}, SampleDeck::fields()); },
              "must be at most",
              "a value above the bound is rejected when the deck is built");
  checkThrows(
      [] {
        inp::applyGiven(json{{"Method", "backward_euler"}},
                        SampleDeck::fields());
      },
      "must be one of",
      "a value outside the accepted set is rejected when the deck is built");
 
  json ok = inp::applyGiven(json{{"Count", 3}}, SampleDeck::fields());
  check(ok.at("Count") == 3, "an accepted value is kept");
 
  // Naming a field must not change whether it appears in the block.
  json given = inp::applyGiven(json{{"Optional", -1.}}, SampleDeck::fields());
  check(given.find("Optional") == given.end(),
        "giving a value the field does not write leaves it out");
  json set = inp::applyGiven(json{{"Optional", 2.5}}, SampleDeck::fields());
  check(set.at("Optional") == 2.5, "giving a value the field writes keeps it");
}

References inp::applyGiven(), check(), checkThrows(), and anonymous_namespace{testDeckField.cpp}::SampleDeck::fields().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

g_checks

int anonymous_namespace{testDeckField.cpp}::g_checks = 0

Definition at line 25 of file testDeckField.cpp.

Referenced by check(), checkThrows(), main(), and run().

g_failures

int anonymous_namespace{testDeckField.cpp}::g_failures = 0

Definition at line 24 of file testDeckField.cpp.

Referenced by check(), checkThrows(), main(), and run().