Ejemplo n.º 1
0
static void
test_set_unset_reset ()
{
  gdb_environ env = gdb_environ::from_host_environ ();

  /* Our test variable should already be present in the host's environment.  */
  SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON") != NULL);

  /* Set our test variable to another value.  */
  env.set ("GDB_SELFTEST_ENVIRON", "test");
  SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON"), "test") == 0);
  SELF_CHECK (env.user_set_env ().size () == 1);
  SELF_CHECK (env.user_unset_env ().size () == 0);

  /* And unset our test variable.  The variable still exists in the
     host's environment, but doesn't exist in our vector.  */
  env.unset ("GDB_SELFTEST_ENVIRON");
  SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON") == NULL);
  SELF_CHECK (env.user_set_env ().size () == 0);
  SELF_CHECK (env.user_unset_env ().size () == 1);
  SELF_CHECK (set_contains (env.user_unset_env (),
			    std::string ("GDB_SELFTEST_ENVIRON")));

  /* Re-set the test variable.  */
  env.set ("GDB_SELFTEST_ENVIRON", "1");
  SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON"), "1") == 0);
}
Ejemplo n.º 2
0
static void
test_vector_clear ()
{
  gdb_environ env;

  env.set (gdb_selftest_env_var, "1");

  env.clear ();
  SELF_CHECK (env.envp ()[0] == NULL);
  SELF_CHECK (env.user_set_env ().size () == 0);
  SELF_CHECK (env.user_unset_env ().size () == 0);
  SELF_CHECK (env.get (gdb_selftest_env_var) == NULL);
}
Ejemplo n.º 3
0
static void
test_vector_initialization ()
{
  gdb_environ env;

  /* When the vector is initialized, there should always be one NULL
     element in it.  */
  SELF_CHECK (env.envp ()[0] == NULL);
  SELF_CHECK (env.user_set_env ().size () == 0);
  SELF_CHECK (env.user_unset_env ().size () == 0);

  /* Make sure that there is no other element.  */
  SELF_CHECK (env.get ("PWD") == NULL);
}
Ejemplo n.º 4
0
static void
test_set_A_unset_B_unset_A_cannot_find_A_can_find_B ()
{
  gdb_environ env;

  env.set ("GDB_SELFTEST_ENVIRON_1", "aaa");
  SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON_1"), "aaa") == 0);
  /* User-set environ var list must contain one element.  */
  SELF_CHECK (env.user_set_env ().size () == 1);
  SELF_CHECK (set_contains (env.user_set_env (),
			    std::string ("GDB_SELFTEST_ENVIRON_1=aaa")));

  env.set ("GDB_SELFTEST_ENVIRON_2", "bbb");
  SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON_2"), "bbb") == 0);

  env.unset ("GDB_SELFTEST_ENVIRON_1");
  SELF_CHECK (env.get ("GDB_SELFTEST_ENVIRON_1") == NULL);
  SELF_CHECK (strcmp (env.get ("GDB_SELFTEST_ENVIRON_2"), "bbb") == 0);

  /* The user-set environ var list must contain only one element
     now.  */
  SELF_CHECK (set_contains (env.user_set_env (),
			    std::string ("GDB_SELFTEST_ENVIRON_2=bbb")));
  SELF_CHECK (env.user_set_env ().size () == 1);
}
Ejemplo n.º 5
0
static void
test_init_from_host_environ ()
{
  /* Initialize the environment vector using the host's environ.  */
  gdb_environ env = gdb_environ::from_host_environ ();

  /* The user-set and user-unset lists must be empty.  */
  SELF_CHECK (env.user_set_env ().size () == 0);
  SELF_CHECK (env.user_unset_env ().size () == 0);

  /* Our test environment variable should be present at the
     vector.  */
  SELF_CHECK (strcmp (env.get (gdb_selftest_env_var), "1") == 0);
}
Ejemplo n.º 6
0
/* Test that the file is unmapped.  */
static void
test_destroy ()
{
  void *mem;

  errno = 0;
  {
    ::scoped_mmap smmap (nullptr, sysconf (_SC_PAGESIZE), PROT_WRITE,
			 MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);

    mem = smmap.get ();
    SELF_CHECK (mem != nullptr);
  }

  SELF_CHECK (msync (mem, sysconf (_SC_PAGESIZE), 0) == -1 && errno == ENOMEM);
}
Ejemplo n.º 7
0
static void
test_appendf_func (string_appendf_func *func)
{
  std::string str;

  func (str, "%s", "");
  SELF_CHECK (str == "");

  func (str, "%s", "test");
  SELF_CHECK (str == "test");

  func (str, "%d", 23);
  SELF_CHECK (str == "test23");

  func (str, "%s %d %s", "foo", 45, "bar");
  SELF_CHECK (str == "test23foo 45 bar");
}
Ejemplo n.º 8
0
/* Test that the memory can be released.  */
static void
test_release ()
{
  void *mem;

  errno = 0;
  {
    ::scoped_mmap smmap (nullptr, sysconf (_SC_PAGESIZE), PROT_WRITE,
			 MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);

    mem = smmap.release ();
    SELF_CHECK (mem != nullptr);
  }

  SELF_CHECK (msync (mem, sysconf (_SC_PAGESIZE), 0) == 0 || errno != ENOMEM);

  munmap (mem, sysconf (_SC_PAGESIZE));
}
Ejemplo n.º 9
0
/* Test the standard usage of mmap_file.  */
static void
test_normal ()
{
  char filename[] = "scoped_mmapped_file-selftest-XXXXXX";
  int fd = mkstemp (filename);
  SELF_CHECK (fd >= 0);

  SELF_CHECK (write (fd, "Hello!", 7) == 7);
  close (fd);

  gdb::unlinker unlink_test_file (filename);

  {
    ::scoped_mmap m = ::mmap_file (filename);

    SELF_CHECK (m.get () != MAP_FAILED);
    SELF_CHECK (m.size () == 7);
    SELF_CHECK (0 == strcmp ((char *) m.get (), "Hello!"));
  }
}
Ejemplo n.º 10
0
static void
test_unset_set_empty_vector ()
{
  gdb_environ env;

  env.set ("PWD", "test");
  SELF_CHECK (strcmp (env.get ("PWD"), "test") == 0);
  SELF_CHECK (set_contains (env.user_set_env (), std::string ("PWD=test")));
  SELF_CHECK (env.user_unset_env ().size () == 0);
  /* The second element must be NULL.  */
  SELF_CHECK (env.envp ()[1] == NULL);
  SELF_CHECK (env.user_set_env ().size () == 1);
  env.unset ("PWD");
  SELF_CHECK (env.envp ()[0] == NULL);
  SELF_CHECK (env.user_set_env ().size () == 0);
  SELF_CHECK (env.user_unset_env ().size () == 1);
  SELF_CHECK (set_contains (env.user_unset_env (), std::string ("PWD")));
}
Ejemplo n.º 11
0
static void
unpack_field_as_long_tests (struct gdbarch *arch)
{
  gdb_byte buffer[8];
  const struct builtin_type *bt = builtin_type (arch);
  struct type *struct_type = arch_composite_type (arch, "<<selftest>>",
						  TYPE_CODE_STRUCT);

  append_composite_type_field (struct_type, "field0", bt->builtin_int8);
  append_composite_type_field_aligned (struct_type, "field1",
				       bt->builtin_uint32, 4);

  memset (buffer, 0, sizeof (buffer));
  buffer[0] = 255;
  if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG)
    buffer[7] = 23;
  else
    buffer[4] = 23;

  SELF_CHECK (unpack_field_as_long (struct_type, buffer, 0) == -1);
  SELF_CHECK (unpack_field_as_long (struct_type, buffer, 1) == 23);
}
Ejemplo n.º 12
0
/* Calling mmap_file with a non-existent file should throw an exception.  */
static void
test_invalid_filename ()
{
  bool threw = false;

  try {
      ::scoped_mmap m = ::mmap_file ("/this/file/should/not/exist");
  } catch (gdb_exception &e) {
      threw = true;
  }

  SELF_CHECK (threw);
}
Ejemplo n.º 13
0
static void
test_reinit_from_host_environ ()
{
  /* Reinitialize our environ vector using the host environ.  We
     should be able to see one (and only one) instance of the test
     variable.  */
  gdb_environ env = gdb_environ::from_host_environ ();
  env = gdb_environ::from_host_environ ();
  char **envp = env.envp ();
  int num_found = 0;

  for (size_t i = 0; envp[i] != NULL; ++i)
    if (strcmp (envp[i], "GDB_SELFTEST_ENVIRON=1") == 0)
      ++num_found;
  SELF_CHECK (num_found == 1);
}
Ejemplo n.º 14
0
static void
common_utils_tests (void)
{
  SELF_CHECK (string_printf ("%s", "") == "");
  SELF_CHECK (string_printf ("%d comes before 2", 1) == "1 comes before 2");
  SELF_CHECK (string_printf ("hello %s", "world") == "hello world");

#define X10 "0123456789"
#define X100 X10 X10 X10 X10 X10 X10 X10 X10 X10 X10
#define X1000 X100 X100 X100 X100 X100 X100 X100 X100 X100 X100
#define X10000 X1000 X1000 X1000 X1000 X1000 X1000 X1000 X1000 X1000 X1000
#define X100000 X10000 X10000 X10000 X10000 X10000 X10000 X10000 X10000 X10000 X10000
  SELF_CHECK (string_printf ("%s", X10) == X10);
  SELF_CHECK (string_printf ("%s", X100) == X100);
  SELF_CHECK (string_printf ("%s", X1000) == X1000);
  SELF_CHECK (string_printf ("%s", X10000) == X10000);
  SELF_CHECK (string_printf ("%s", X100000) == X100000);
}
Ejemplo n.º 15
0
static void
test_self_move ()
{
  gdb_environ env;

  /* Test self-move.  */
  env.set ("A", "1");
  SELF_CHECK (strcmp (env.get ("A"), "1") == 0);
  SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1")));
  SELF_CHECK (env.user_set_env ().size () == 1);

  /* Some compilers warn about moving to self, but that's precisely what we want
     to test here, so turn this warning off.  */
  DIAGNOSTIC_PUSH
  DIAGNOSTIC_IGNORE_SELF_MOVE
  env = std::move (env);
  DIAGNOSTIC_POP

  SELF_CHECK (strcmp (env.get ("A"), "1") == 0);
  SELF_CHECK (strcmp (env.envp ()[0], "A=1") == 0);
  SELF_CHECK (env.envp ()[1] == NULL);
  SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1")));
  SELF_CHECK (env.user_set_env ().size () == 1);
}
static void
aarch64_tdesc_test ()
{
  const target_desc *tdesc = aarch64_linux_read_description (0);
  SELF_CHECK (*tdesc == *tdesc_aarch64);
}
Ejemplo n.º 17
0
static void
test ()
{
  SELF_CHECK (child_path_check ("/one", "/two", NULL));
  SELF_CHECK (child_path_check ("/one", "/one", NULL));
  SELF_CHECK (child_path_check ("/one", "/one/", NULL));
  SELF_CHECK (child_path_check ("/one", "/one//", NULL));
  SELF_CHECK (child_path_check ("/one", "/one/two", "two"));
  SELF_CHECK (child_path_check ("/one/", "/two", NULL));
  SELF_CHECK (child_path_check ("/one/", "/one", NULL));
  SELF_CHECK (child_path_check ("/one/", "/one/", NULL));
  SELF_CHECK (child_path_check ("/one/", "/one//", NULL));
  SELF_CHECK (child_path_check ("/one/", "/one/two", "two"));
  SELF_CHECK (child_path_check ("/one/", "/one//two", "two"));
  SELF_CHECK (child_path_check ("/one/", "/one//two/", "two/"));
  SELF_CHECK (child_path_check ("/one", "/onetwo", NULL));
  SELF_CHECK (child_path_check ("/one", "/onetwo/three", NULL));
}
Ejemplo n.º 18
0
static void
run_tests ()
{
  capacity_1::main ();
  cons_1::main ();
  cons_2::main ();
  cons_3::main ();
  element_access_1::main ();
  element_access_empty::main ();
  element_access_front_back::main ();
  inserters_2::main ();
  modifiers_remove_prefix::main ();
  modifiers_remove_suffix::main ();
  modifiers_swap::test01 ();
  operations_compare_1::main ();
  operations_compare_13650::main ();
  operations_copy_1::main ();
  operations_data_1::main ();
  operations_find_1::main ();
  operations_find_2::main ();
  operations_find_3::main ();
  operations_find_4::main ();
  operations_rfind_1::main ();
  operations_rfind_2::main ();
  operations_rfind_3::main ();
  operations_substr_1::main ();
  operators_2::main ();

  constexpr gdb::string_view sv_empty;
  SELF_CHECK (sv_empty.empty ());

  std::string std_string = "fika";
  gdb::string_view sv1 (std_string);
  SELF_CHECK (sv1 == "fika");

  constexpr const char *fika = "fika";
  gdb::string_view sv2 (fika);
  SELF_CHECK (sv2 == "fika");

  constexpr gdb::string_view sv3 (fika, 3);
  SELF_CHECK (sv3 == "fik");

  constexpr gdb::string_view sv4 (sv3);
  SELF_CHECK (sv4 == "fik");

  constexpr gdb::string_view::iterator it_begin = sv4.begin ();
  static_assert (*it_begin == 'f', "");

  constexpr gdb::string_view::iterator it_end = sv4.end ();
  static_assert (*it_end == 'a', "");

  const gdb::string_view::reverse_iterator it_rbegin = sv4.rbegin ();
  SELF_CHECK (*it_rbegin == 'k');

  const gdb::string_view::reverse_iterator it_rend = sv4.rend ();
  SELF_CHECK (*(it_rend - 1) == 'f');

  constexpr gdb::string_view::size_type size = sv4.size ();
  static_assert (size == 3, "");

  constexpr gdb::string_view::size_type length = sv4.length ();
  static_assert (length == 3, "");

  constexpr gdb::string_view::size_type max_size = sv4.max_size ();
  static_assert (max_size > 0, "");

  constexpr bool empty = sv4.empty ();
  static_assert (!empty, "");

  constexpr char c1 = sv4[1];
  static_assert (c1 == 'i', "");

  constexpr char c2 = sv4.at (2);
  static_assert (c2 == 'k', "");

  constexpr char front = sv4.front ();
  static_assert (front == 'f', "");

  constexpr char back = sv4.back ();
  static_assert (back == 'k', "");

  constexpr const char *data = sv4.data ();
  static_assert (data == fika, "");
}
Ejemplo n.º 19
0
static void
test_move_constructor ()
{
  gdb_environ env;

  env.set ("A", "1");
  SELF_CHECK (strcmp (env.get ("A"), "1") == 0);
  SELF_CHECK (set_contains (env.user_set_env (), std::string ("A=1")));

  gdb_environ env2 = std::move (env);
  SELF_CHECK (env.envp ()[0] == NULL);
  SELF_CHECK (env.user_set_env ().size () == 0);
  SELF_CHECK (strcmp (env2.get ("A"), "1") == 0);
  SELF_CHECK (env2.envp ()[1] == NULL);
  SELF_CHECK (set_contains (env2.user_set_env (), std::string ("A=1")));
  SELF_CHECK (env2.user_set_env ().size () == 1);

  env.set ("B", "2");
  SELF_CHECK (strcmp (env.get ("B"), "2") == 0);
  SELF_CHECK (env.envp ()[1] == NULL);
  SELF_CHECK (set_contains (env.user_set_env (), std::string ("B=2")));
  SELF_CHECK (env.user_set_env ().size () == 1);
}