diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 18:45:59 +0000 |
commit | 19fcec84d8d7d21e796c7624e521b60d28ee21ed (patch) | |
tree | 42d26aa27d1e3f7c0b8bd3fd14e7d7082f5008dc /src/c-ares/test/ares-test-init.cc | |
parent | Initial commit. (diff) | |
download | ceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.tar.xz ceph-19fcec84d8d7d21e796c7624e521b60d28ee21ed.zip |
Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | src/c-ares/test/ares-test-init.cc | 595 |
1 files changed, 595 insertions, 0 deletions
diff --git a/src/c-ares/test/ares-test-init.cc b/src/c-ares/test/ares-test-init.cc new file mode 100644 index 000000000..66570ace5 --- /dev/null +++ b/src/c-ares/test/ares-test-init.cc @@ -0,0 +1,595 @@ +#include "ares-test.h" + +// library initialization is only needed for windows builds +#ifdef WIN32 +#define EXPECTED_NONINIT ARES_ENOTINITIALIZED +#else +#define EXPECTED_NONINIT ARES_SUCCESS +#endif + +namespace ares { +namespace test { + +TEST(LibraryInit, Basic) { + EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized()); + EXPECT_EQ(ARES_SUCCESS, ares_library_init(ARES_LIB_INIT_ALL)); + EXPECT_EQ(ARES_SUCCESS, ares_library_initialized()); + ares_library_cleanup(); + EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized()); +} + +TEST(LibraryInit, UnexpectedCleanup) { + EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized()); + ares_library_cleanup(); + EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized()); +} + +TEST(LibraryInit, DISABLED_InvalidParam) { + // TODO: police flags argument to ares_library_init() + EXPECT_EQ(ARES_EBADQUERY, ares_library_init(ARES_LIB_INIT_ALL << 2)); + EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized()); + ares_library_cleanup(); +} + +TEST(LibraryInit, Nested) { + EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized()); + EXPECT_EQ(ARES_SUCCESS, ares_library_init(ARES_LIB_INIT_ALL)); + EXPECT_EQ(ARES_SUCCESS, ares_library_initialized()); + EXPECT_EQ(ARES_SUCCESS, ares_library_init(ARES_LIB_INIT_ALL)); + EXPECT_EQ(ARES_SUCCESS, ares_library_initialized()); + ares_library_cleanup(); + EXPECT_EQ(ARES_SUCCESS, ares_library_initialized()); + ares_library_cleanup(); + EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized()); +} + +TEST(LibraryInit, BasicChannelInit) { + EXPECT_EQ(ARES_SUCCESS, ares_library_init(ARES_LIB_INIT_ALL)); + ares_channel channel = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + EXPECT_NE(nullptr, channel); + ares_destroy(channel); + ares_library_cleanup(); +} + +TEST_F(LibraryTest, OptionsChannelInit) { + struct ares_options opts = {0}; + int optmask = 0; + opts.flags = ARES_FLAG_USEVC | ARES_FLAG_PRIMARY; + optmask |= ARES_OPT_FLAGS; + opts.timeout = 2000; + optmask |= ARES_OPT_TIMEOUTMS; + opts.tries = 2; + optmask |= ARES_OPT_TRIES; + opts.ndots = 4; + optmask |= ARES_OPT_NDOTS; + opts.udp_port = 54; + optmask |= ARES_OPT_UDP_PORT; + opts.tcp_port = 54; + optmask |= ARES_OPT_TCP_PORT; + opts.socket_send_buffer_size = 514; + optmask |= ARES_OPT_SOCK_SNDBUF; + opts.socket_receive_buffer_size = 514; + optmask |= ARES_OPT_SOCK_RCVBUF; + opts.ednspsz = 1280; + optmask |= ARES_OPT_EDNSPSZ; + opts.nservers = 2; + opts.servers = (struct in_addr *)malloc(opts.nservers * sizeof(struct in_addr)); + opts.servers[0].s_addr = htonl(0x01020304); + opts.servers[1].s_addr = htonl(0x02030405); + optmask |= ARES_OPT_SERVERS; + opts.ndomains = 2; + opts.domains = (char **)malloc(opts.ndomains * sizeof(char *)); + opts.domains[0] = strdup("example.com"); + opts.domains[1] = strdup("example2.com"); + optmask |= ARES_OPT_DOMAINS; + opts.lookups = strdup("b"); + optmask |= ARES_OPT_LOOKUPS; + optmask |= ARES_OPT_ROTATE; + + ares_channel channel = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_init_options(&channel, &opts, optmask)); + EXPECT_NE(nullptr, channel); + + ares_channel channel2 = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_dup(&channel2, channel)); + + struct ares_options opts2 = {0}; + int optmask2 = 0; + EXPECT_EQ(ARES_SUCCESS, ares_save_options(channel2, &opts2, &optmask2)); + + // Note that not all opts-settable fields are saved (e.g. + // ednspsz, socket_{send,receive}_buffer_size). + EXPECT_EQ(opts.flags, opts2.flags); + EXPECT_EQ(opts.timeout, opts2.timeout); + EXPECT_EQ(opts.tries, opts2.tries); + EXPECT_EQ(opts.ndots, opts2.ndots); + EXPECT_EQ(opts.udp_port, opts2.udp_port); + EXPECT_EQ(opts.tcp_port, opts2.tcp_port); + EXPECT_EQ(1, opts2.nservers); // Truncated by ARES_FLAG_PRIMARY + EXPECT_EQ(opts.servers[0].s_addr, opts2.servers[0].s_addr); + EXPECT_EQ(opts.ndomains, opts2.ndomains); + EXPECT_EQ(std::string(opts.domains[0]), std::string(opts2.domains[0])); + EXPECT_EQ(std::string(opts.domains[1]), std::string(opts2.domains[1])); + EXPECT_EQ(std::string(opts.lookups), std::string(opts2.lookups)); + + ares_destroy_options(&opts); + ares_destroy_options(&opts2); + ares_destroy(channel); + ares_destroy(channel2); +} + +TEST_F(LibraryTest, ChannelAllocFail) { + ares_channel channel; + for (int ii = 1; ii <= 25; ii++) { + ClearFails(); + SetAllocFail(ii); + channel = nullptr; + int rc = ares_init(&channel); + // The number of allocations depends on local environment, so don't expect ENOMEM. + if (rc == ARES_ENOMEM) { + EXPECT_EQ(nullptr, channel); + } else { + ares_destroy(channel); + } + } +} + +TEST_F(LibraryTest, OptionsChannelAllocFail) { + struct ares_options opts = {0}; + int optmask = 0; + opts.flags = ARES_FLAG_USEVC; + optmask |= ARES_OPT_FLAGS; + opts.timeout = 2; + optmask |= ARES_OPT_TIMEOUT; + opts.tries = 2; + optmask |= ARES_OPT_TRIES; + opts.ndots = 4; + optmask |= ARES_OPT_NDOTS; + opts.udp_port = 54; + optmask |= ARES_OPT_UDP_PORT; + opts.tcp_port = 54; + optmask |= ARES_OPT_TCP_PORT; + opts.socket_send_buffer_size = 514; + optmask |= ARES_OPT_SOCK_SNDBUF; + opts.socket_receive_buffer_size = 514; + optmask |= ARES_OPT_SOCK_RCVBUF; + opts.ednspsz = 1280; + optmask |= ARES_OPT_EDNSPSZ; + opts.nservers = 2; + opts.servers = (struct in_addr *)malloc(opts.nservers * sizeof(struct in_addr)); + opts.servers[0].s_addr = htonl(0x01020304); + opts.servers[1].s_addr = htonl(0x02030405); + optmask |= ARES_OPT_SERVERS; + opts.ndomains = 2; + opts.domains = (char **)malloc(opts.ndomains * sizeof(char *)); + opts.domains[0] = strdup("example.com"); + opts.domains[1] = strdup("example2.com"); + optmask |= ARES_OPT_DOMAINS; + opts.lookups = strdup("b"); + optmask |= ARES_OPT_LOOKUPS; + optmask |= ARES_OPT_ROTATE; + + ares_channel channel = nullptr; + for (int ii = 1; ii <= 8; ii++) { + ClearFails(); + SetAllocFail(ii); + int rc = ares_init_options(&channel, &opts, optmask); + if (rc == ARES_ENOMEM) { + EXPECT_EQ(nullptr, channel); + } else { + EXPECT_EQ(ARES_SUCCESS, rc); + ares_destroy(channel); + channel = nullptr; + } + } + ClearFails(); + + EXPECT_EQ(ARES_SUCCESS, ares_init_options(&channel, &opts, optmask)); + EXPECT_NE(nullptr, channel); + + // Add some servers and a sortlist for flavour. + EXPECT_EQ(ARES_SUCCESS, + ares_set_servers_csv(channel, "1.2.3.4,0102:0304:0506:0708:0910:1112:1314:1516,2.3.4.5")); + EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel, "1.2.3.4 2.3.4.5")); + + ares_channel channel2 = nullptr; + for (int ii = 1; ii <= 18; ii++) { + ClearFails(); + SetAllocFail(ii); + EXPECT_EQ(ARES_ENOMEM, ares_dup(&channel2, channel)) << ii; + EXPECT_EQ(nullptr, channel2) << ii; + } + + struct ares_options opts2; + int optmask2 = 0; + for (int ii = 1; ii <= 6; ii++) { + memset(&opts2, 0, sizeof(opts2)); + ClearFails(); + SetAllocFail(ii); + EXPECT_EQ(ARES_ENOMEM, ares_save_options(channel, &opts2, &optmask2)) << ii; + // May still have allocations even after ARES_ENOMEM return code. + ares_destroy_options(&opts2); + } + ares_destroy_options(&opts); + ares_destroy(channel); +} + +TEST_F(LibraryTest, FailChannelInit) { + EXPECT_EQ(ARES_SUCCESS, + ares_library_init_mem(ARES_LIB_INIT_ALL, + &LibraryTest::amalloc, + &LibraryTest::afree, + &LibraryTest::arealloc)); + SetAllocFail(1); + ares_channel channel = nullptr; + EXPECT_EQ(ARES_ENOMEM, ares_init(&channel)); + EXPECT_EQ(nullptr, channel); + ares_library_cleanup(); +} + +#ifndef WIN32 +TEST_F(LibraryTest, EnvInit) { + ares_channel channel = nullptr; + EnvValue v1("LOCALDOMAIN", "this.is.local"); + EnvValue v2("RES_OPTIONS", "options debug ndots:3 retry:3 rotate retrans:2"); + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + ares_destroy(channel); +} + +TEST_F(LibraryTest, EnvInitAllocFail) { + ares_channel channel; + EnvValue v1("LOCALDOMAIN", "this.is.local"); + EnvValue v2("RES_OPTIONS", "options debug ndots:3 retry:3 rotate retrans:2"); + for (int ii = 1; ii <= 10; ii++) { + ClearFails(); + SetAllocFail(ii); + channel = nullptr; + int rc = ares_init(&channel); + if (rc == ARES_SUCCESS) { + ares_destroy(channel); + } else { + EXPECT_EQ(ARES_ENOMEM, rc); + } + } +} +#endif + +TEST_F(DefaultChannelTest, SetAddresses) { + ares_set_local_ip4(channel_, 0x01020304); + byte addr6[16] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10}; + ares_set_local_ip6(channel_, addr6); + ares_set_local_dev(channel_, "dummy"); +} + +TEST_F(DefaultChannelTest, SetSortlistFailures) { + EXPECT_EQ(ARES_ENODATA, ares_set_sortlist(nullptr, "1.2.3.4")); + EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "xyzzy ; lwk")); + EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "xyzzy ; 0x123")); +} + +TEST_F(DefaultChannelTest, SetSortlistVariants) { + EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "1.2.3.4")); + EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "1.2.3.4 ; 2.3.4.5")); + EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "129.1.1.1")); + EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "192.1.1.1")); + EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "224.1.1.1")); + EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "225.1.1.1")); +} + +TEST_F(DefaultChannelTest, SetSortlistAllocFail) { + for (int ii = 1; ii <= 3; ii++) { + ClearFails(); + SetAllocFail(ii); + EXPECT_EQ(ARES_ENOMEM, ares_set_sortlist(channel_, "12.13.0.0/16 1234::5678/40 1.2.3.4")) << ii; + } +} + +#ifdef USE_WINSOCK +TEST(Init, NoLibraryInit) { + ares_channel channel = nullptr; + EXPECT_EQ(ARES_ENOTINITIALIZED, ares_init(&channel)); +} +#endif + +#ifdef HAVE_CONTAINER +// These tests rely on the ability of non-root users to create a chroot +// using Linux namespaces. + + +// The library uses a variety of information sources to initialize a channel, +// in particular to determine: +// - search: the search domains to use +// - servers: the name servers to use +// - lookup: whether to check files or DNS or both (e.g. "fb") +// - options: various resolver options +// - sortlist: the order of preference for IP addresses +// +// The first source from the following list is used: +// - init_by_options(): explicitly specified values in struct ares_options +// - init_by_environment(): values from the environment: +// - LOCALDOMAIN -> search (single value) +// - RES_OPTIONS -> options +// - init_by_resolv_conf(): values from various config files: +// - /etc/resolv.conf -> search, lookup, servers, sortlist, options +// - /etc/nsswitch.conf -> lookup +// - /etc/host.conf -> lookup +// - /etc/svc.conf -> lookup +// - init_by_defaults(): fallback values: +// - gethostname(3) -> domain +// - "fb" -> lookup + +NameContentList filelist = { + {"/etc/resolv.conf", "nameserver 1.2.3.4\n" + "sortlist 1.2.3.4/16 2.3.4.5\n" + "search first.com second.com\n"}, + {"/etc/hosts", "3.4.5.6 ahostname.com\n"}, + {"/etc/nsswitch.conf", "hosts: files\n"}}; +CONTAINED_TEST_F(LibraryTest, ContainerChannelInit, + "myhostname", "mydomainname.org", filelist) { + ares_channel channel = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + std::vector<std::string> actual = GetNameServers(channel); + std::vector<std::string> expected = {"1.2.3.4"}; + EXPECT_EQ(expected, actual); + + struct ares_options opts; + int optmask = 0; + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(2, opts.ndomains); + EXPECT_EQ(std::string("first.com"), std::string(opts.domains[0])); + EXPECT_EQ(std::string("second.com"), std::string(opts.domains[1])); + ares_destroy_options(&opts); + + HostResult result; + ares_gethostbyname(channel, "ahostname.com", AF_INET, HostCallback, &result); + ProcessWork(channel, NoExtraFDs, nullptr); + EXPECT_TRUE(result.done_); + std::stringstream ss; + ss << result.host_; + EXPECT_EQ("{'ahostname.com' aliases=[] addrs=[3.4.5.6]}", ss.str()); + + ares_destroy(channel); + return HasFailure(); +} + +CONTAINED_TEST_F(LibraryTest, ContainerSortlistOptionInit, + "myhostname", "mydomainname.org", filelist) { + ares_channel channel = nullptr; + struct ares_options opts = {0}; + int optmask = 0; + optmask |= ARES_OPT_SORTLIST; + opts.nsort = 0; + // Explicitly specifying an empty sortlist in the options should override the + // environment. + EXPECT_EQ(ARES_SUCCESS, ares_init_options(&channel, &opts, optmask)); + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(0, opts.nsort); + EXPECT_EQ(nullptr, opts.sortlist); + EXPECT_EQ(ARES_OPT_SORTLIST, (optmask & ARES_OPT_SORTLIST)); + ares_destroy_options(&opts); + + ares_destroy(channel); + return HasFailure(); +} + +NameContentList fullresolv = { + {"/etc/resolv.conf", " nameserver 1.2.3.4 \n" + "search first.com second.com\n" + "lookup bind\n" + "options debug ndots:5\n" + "sortlist 1.2.3.4/16 2.3.4.5\n"}}; +CONTAINED_TEST_F(LibraryTest, ContainerFullResolvInit, + "myhostname", "mydomainname.org", fullresolv) { + ares_channel channel = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + + struct ares_options opts; + int optmask = 0; + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(std::string("b"), std::string(opts.lookups)); + EXPECT_EQ(5, opts.ndots); + ares_destroy_options(&opts); + + ares_destroy(channel); + return HasFailure(); +} + +NameContentList hostconf = { + {"/etc/resolv.conf", "nameserver 1.2.3.4\n" + "sortlist1.2.3.4\n" // malformed line + "search first.com second.com\n"}, + {"/etc/host.conf", "order bind hosts\n"}}; +CONTAINED_TEST_F(LibraryTest, ContainerHostConfInit, + "myhostname", "mydomainname.org", hostconf) { + ares_channel channel = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + + struct ares_options opts; + int optmask = 0; + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(std::string("bf"), std::string(opts.lookups)); + ares_destroy_options(&opts); + + ares_destroy(channel); + return HasFailure(); +} + +NameContentList svcconf = { + {"/etc/resolv.conf", "nameserver 1.2.3.4\n" + "search first.com second.com\n"}, + {"/etc/svc.conf", "hosts= bind\n"}}; +CONTAINED_TEST_F(LibraryTest, ContainerSvcConfInit, + "myhostname", "mydomainname.org", svcconf) { + ares_channel channel = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + + struct ares_options opts; + int optmask = 0; + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(std::string("b"), std::string(opts.lookups)); + ares_destroy_options(&opts); + + ares_destroy(channel); + return HasFailure(); +} + +// Failures when expected config filenames are inaccessible. +class MakeUnreadable { + public: + explicit MakeUnreadable(const std::string& filename) + : filename_(filename) { + chmod(filename_.c_str(), 0000); + } + ~MakeUnreadable() { chmod(filename_.c_str(), 0644); } + private: + std::string filename_; +}; + +CONTAINED_TEST_F(LibraryTest, ContainerResolvConfNotReadable, + "myhostname", "mydomainname.org", filelist) { + ares_channel channel = nullptr; + MakeUnreadable hide("/etc/resolv.conf"); + // Unavailable /etc/resolv.conf falls back to defaults + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + return HasFailure(); +} +CONTAINED_TEST_F(LibraryTest, ContainerNsswitchConfNotReadable, + "myhostname", "mydomainname.org", filelist) { + ares_channel channel = nullptr; + // Unavailable /etc/nsswitch.conf falls back to defaults. + MakeUnreadable hide("/etc/nsswitch.conf"); + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + + struct ares_options opts; + int optmask = 0; + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(std::string("fb"), std::string(opts.lookups)); + ares_destroy_options(&opts); + + ares_destroy(channel); + return HasFailure(); +} +CONTAINED_TEST_F(LibraryTest, ContainerHostConfNotReadable, + "myhostname", "mydomainname.org", hostconf) { + ares_channel channel = nullptr; + // Unavailable /etc/host.conf falls back to defaults. + MakeUnreadable hide("/etc/host.conf"); + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + ares_destroy(channel); + return HasFailure(); +} +CONTAINED_TEST_F(LibraryTest, ContainerSvcConfNotReadable, + "myhostname", "mydomainname.org", svcconf) { + ares_channel channel = nullptr; + // Unavailable /etc/svc.conf falls back to defaults. + MakeUnreadable hide("/etc/svc.conf"); + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + ares_destroy(channel); + return HasFailure(); +} + +NameContentList rotateenv = { + {"/etc/resolv.conf", "nameserver 1.2.3.4\n" + "search first.com second.com\n" + "options rotate\n"}}; +CONTAINED_TEST_F(LibraryTest, ContainerRotateInit, + "myhostname", "mydomainname.org", rotateenv) { + ares_channel channel = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + + struct ares_options opts; + int optmask = 0; + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(ARES_OPT_ROTATE, (optmask & ARES_OPT_ROTATE)); + ares_destroy_options(&opts); + + ares_destroy(channel); + return HasFailure(); +} + +CONTAINED_TEST_F(LibraryTest, ContainerRotateOverride, + "myhostname", "mydomainname.org", rotateenv) { + ares_channel channel = nullptr; + struct ares_options opts = {0}; + int optmask = ARES_OPT_NOROTATE; + EXPECT_EQ(ARES_SUCCESS, ares_init_options(&channel, &opts, optmask)); + + optmask = 0; + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(ARES_OPT_NOROTATE, (optmask & ARES_OPT_NOROTATE)); + ares_destroy_options(&opts); + + ares_destroy(channel); + return HasFailure(); +} + +NameContentList multiresolv = { + {"/etc/resolv.conf", " nameserver 1::2 ; ;;\n" + " domain first.com\n"}, + {"/etc/nsswitch.conf", "hosts: files\n"}}; +CONTAINED_TEST_F(LibraryTest, ContainerMultiResolvInit, + "myhostname", "mydomainname.org", multiresolv) { + ares_channel channel = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + std::vector<std::string> actual = GetNameServers(channel); + std::vector<std::string> expected = {"0001:0000:0000:0000:0000:0000:0000:0002"}; + EXPECT_EQ(expected, actual); + + struct ares_options opts; + int optmask = 0; + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(1, opts.ndomains); + EXPECT_EQ(std::string("first.com"), std::string(opts.domains[0])); + ares_destroy_options(&opts); + + ares_destroy(channel); + return HasFailure(); +} + +NameContentList systemdresolv = { + {"/etc/resolv.conf", "nameserver 1.2.3.4\n" + "domain first.com\n"}, + {"/etc/nsswitch.conf", "hosts: junk resolve files\n"}}; +CONTAINED_TEST_F(LibraryTest, ContainerSystemdResolvInit, + "myhostname", "mydomainname.org", systemdresolv) { + ares_channel channel = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + + struct ares_options opts; + int optmask = 0; + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(std::string("bf"), std::string(opts.lookups)); + ares_destroy_options(&opts); + + ares_destroy(channel); + return HasFailure(); +} + +NameContentList empty = {}; // no files +CONTAINED_TEST_F(LibraryTest, ContainerEmptyInit, + "host.domain.org", "domain.org", empty) { + ares_channel channel = nullptr; + EXPECT_EQ(ARES_SUCCESS, ares_init(&channel)); + std::vector<std::string> actual = GetNameServers(channel); + std::vector<std::string> expected = {"127.0.0.1"}; + EXPECT_EQ(expected, actual); + + struct ares_options opts; + int optmask = 0; + ares_save_options(channel, &opts, &optmask); + EXPECT_EQ(1, opts.ndomains); + EXPECT_EQ(std::string("domain.org"), std::string(opts.domains[0])); + EXPECT_EQ(std::string("fb"), std::string(opts.lookups)); + ares_destroy_options(&opts); + + + ares_destroy(channel); + return HasFailure(); +} + +#endif + +} // namespace test +} // namespace ares |