keymap_defaults_t.cc File Reference

#include "boost/test/unit_test.hpp"
#include "KeyMap.h"
#include "fhiclcpp/types/Atom.h"
#include "fhiclcpp/types/Sequence.h"
#include "fhiclcpp/types/Tuple.h"
#include <string>

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   (keymap test)

Functions
	BOOST_AUTO_TEST_CASE (one_atom_t)
	BOOST_AUTO_TEST_CASE (one_sequence_t)
	BOOST_AUTO_TEST_CASE (one_sequence_2_t)
	BOOST_AUTO_TEST_CASE (one_tuple_t)
	BOOST_AUTO_TEST_CASE (seq_in_tuple_t)
	BOOST_AUTO_TEST_CASE (bounded_seq_in_tuple_t)
	BOOST_AUTO_TEST_CASE (tuple_in_tuple_t)
	BOOST_AUTO_TEST_CASE (tuple_in_seq_t)
	BOOST_AUTO_TEST_CASE (tuple_in_seq_2_t)
	BOOST_AUTO_TEST_CASE (seq_in_seq_t)
	BOOST_AUTO_TEST_CASE (seq_2_in_seq_t)
	BOOST_AUTO_TEST_CASE (seq_in_seq_2_t)
	BOOST_AUTO_TEST_CASE (seq_2_in_seq_2_t)

Macro Definition Documentation

#define BOOST_TEST_MODULE   (keymap test)

Definition at line 11 of file keymap_defaults_t.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

one_atom_t

)

Definition at line 29 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Atom<int> test{Name("atom"), 4};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {"atom"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

one_sequence_t

)

Definition at line 41 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Sequence<int> test{Name("sequence"), {1, 2, 4}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {"sequence", "sequence[0]", "sequence[1]", "sequence[2]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

one_sequence_2_t

)

Definition at line 53 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Sequence<int, 2> test{Name("sequence"), {5, 7}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {"sequence", "sequence[0]", "sequence[1]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

one_tuple_t

)

Definition at line 65 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Tuple<int, double, bool> test{Name("tuple"), {4, 1.5, false}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {"tuple", "tuple[0]", "tuple[1]", "tuple[2]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

seq_in_tuple_t

)

Definition at line 77 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Tuple<Sequence<int>, double, bool> test{Name("tuple"),
                                          {{1, 3, 5}, 4.6, true}};
  km.walk_over(test);

  auto map = km.result(); // key_map(&test);
  auto ref = {"tuple",
              "tuple[0]",
              "tuple[0][0]",
              "tuple[0][1]",
              "tuple[0][2]",
              "tuple[1]",
              "tuple[2]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

bounded_seq_in_tuple_t

)

Definition at line 96 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Tuple<Sequence<int, 2>, double, bool> test{Name("tuple"),
                                             {{9, 15}, 0.2, false}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {
    "tuple", "tuple[0]", "tuple[0][0]", "tuple[0][1]", "tuple[1]", "tuple[2]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

tuple_in_tuple_t

)

Definition at line 110 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Tuple<Tuple<int, float>, double, bool> test{Name("tuple"),
                                              {{4, 3.7f}, 8.1, true}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {
    "tuple", "tuple[0]", "tuple[0][0]", "tuple[0][1]", "tuple[1]", "tuple[2]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

tuple_in_seq_t

)

Definition at line 124 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Sequence<Tuple<int, float>> test{Name("seqtuple"),
                                   {{2, 5.4f}, {4, 104.5f}, {8, 15.3f}}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {"seqtuple",
              "seqtuple[0]",
              "seqtuple[0][0]",
              "seqtuple[0][1]",
              "seqtuple[1]",
              "seqtuple[1][0]",
              "seqtuple[1][1]",
              "seqtuple[2]",
              "seqtuple[2][0]",
              "seqtuple[2][1]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

tuple_in_seq_2_t

)

Definition at line 146 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Sequence<Tuple<int, float>, 2> test{Name("seqtuple"), {{1, 2.3f}, {9, 3.2f}}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {"seqtuple",
              "seqtuple[0]",
              "seqtuple[0][0]",
              "seqtuple[0][1]",
              "seqtuple[1]",
              "seqtuple[1][0]",
              "seqtuple[1][1]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

seq_in_seq_t

)

Definition at line 164 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Sequence<Sequence<int>> test{Name("seqseq"), {{1, 5, 7}, {2}}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {"seqseq",
              "seqseq[0]",
              "seqseq[0][0]",
              "seqseq[0][1]",
              "seqseq[0][2]",
              "seqseq[1]",
              "seqseq[1][0]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

seq_2_in_seq_t

)

Definition at line 182 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Sequence<Sequence<int, 2>> test{Name("seqseq"), {{1, 2}}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {"seqseq", "seqseq[0]", "seqseq[0][0]", "seqseq[0][1]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

seq_in_seq_2_t

)

Definition at line 194 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Sequence<Sequence<int>, 2> test{Name("seqseq"), {{4}, {1, 4, 9, 1}}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {"seqseq",
              "seqseq[0]",
              "seqseq[0][0]",
              "seqseq[1]",
              "seqseq[1][0]",
              "seqseq[1][1]",
              "seqseq[1][2]",
              "seqseq[1][3]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}

BOOST_AUTO_TEST_CASE

(

seq_2_in_seq_2_t

)

Definition at line 213 of file keymap_defaults_t.cc.

{
  KeyMap km;
  Sequence<Sequence<int, 2>, 2> test{Name("seqseq"), {{6, 7}, {2, 1}}};
  km.walk_over(test);

  auto map = km.result();
  auto ref = {"seqseq",
              "seqseq[0]",
              "seqseq[0][0]",
              "seqseq[0][1]",
              "seqseq[1]",
              "seqseq[1][0]",
              "seqseq[1][1]"};
  BOOST_TEST(map == ref, boost::test_tools::per_element{});
}