public:

LibraryTest() {

EXPECT_EQ(ARES_SUCCESS,

ares_library_init_mem(ARES_LIB_INIT_ALL,

&LibraryTest::amalloc,

&LibraryTest::afree,

&LibraryTest::arealloc));

}

~LibraryTest() {

ares_library_cleanup();

ClearFails();

}

// Set the n-th malloc call (of any size) from the library to fail.

// (nth == 1 means the next call)

static void SetAllocFail(int nth);

// Set the next malloc call for the given size to fail.

static void SetAllocSizeFail(size_t size);

// Remove any pending alloc failures.

static void ClearFails();

static void *amalloc(size_t size);

static void* arealloc(void *ptr, size_t size);

static void afree(void *ptr);

private:

static bool ShouldAllocFail(size_t size);

static unsigned long long fails_;

static std::map<size_t, int> size_fails_;

public:

DefaultChannelTest() : channel_(nullptr) {

EXPECT_EQ(ARES_SUCCESS, ares_init(&channel_));

EXPECT_NE(nullptr, channel_);

}

~DefaultChannelTest() {

ares_destroy(channel_);

channel_ = nullptr;

}

// Process all pending work on ares-owned file descriptors.

void Process();

protected:

ares_channel channel_;

: public LibraryTest,

public ::testing::WithParamInterface<std::string> {

public:

DefaultChannelModeTest() : channel_(nullptr) {

struct ares_options opts = {0};

opts.lookups = strdup(GetParam().c_str());

int optmask = ARES_OPT_LOOKUPS;

EXPECT_EQ(ARES_SUCCESS, ares_init_options(&channel_, &opts, optmask));

EXPECT_NE(nullptr, channel_);

free(opts.lookups);

}

~DefaultChannelModeTest() {

ares_destroy(channel_);

channel_ = nullptr;

}

// Process all pending work on ares-owned file descriptors.

void Process();

protected:

ares_channel channel_;

public:

MockServer(int family, int port);

~MockServer();

// Mock method indicating the processing of a particular <name, RRtype>

// request.

MOCK_METHOD2(OnRequest, void(const std::string& name, int rrtype));

// Set the reply to be sent next; the query ID field will be overwritten

// with the value from the request.

void SetReplyData(const std::vector<byte>& reply) { reply_ = reply; }

void SetReply(const DNSPacket* reply) { SetReplyData(reply->data()); }

void SetReplyQID(int qid) { qid_ = qid; }

// The set of file descriptors that the server handles.

std::set<int> fds() const;

// Process activity on a file descriptor.

void ProcessFD(int fd);

// Ports the server is responding to

int udpport() const { return udpport_; }

int tcpport() const { return tcpport_; }

private:

void ProcessRequest(int fd, struct sockaddr_storage* addr, int addrlen,

int qid, const std::string& name, int rrtype);

void ProcessPacket(int fd, struct sockaddr_storage *addr, socklen_t addrlen,

byte *data, int len);

int udpport_;

int tcpport_;

int udpfd_;

int tcpfd_;

std::set<int> connfds_;

std::vector<byte> reply_;

int qid_;

public:

MockChannelOptsTest(int count, int family, bool force_tcp, struct ares_options* givenopts, int optmask);

~MockChannelOptsTest();

// Process all pending work on ares-owned and mock-server-owned file descriptors.

void Process();

protected:

// NiceMockServer doesn't complain about uninteresting calls.

typedef testing::NiceMock<MockServer> NiceMockServer;

typedef std::vector< std::unique_ptr<NiceMockServer> > NiceMockServers;

std::set<int> fds() const;

void ProcessFD(int fd);

static NiceMockServers BuildServers(int count, int family, int base_port);

NiceMockServers servers_;

// Convenience reference to first server.

NiceMockServer& server_;

ares_channel channel_;

: public MockChannelOptsTest,

public ::testing::WithParamInterface< std::pair<int, bool> > {

public:

MockChannelTest() : MockChannelOptsTest(1, GetParam().first, GetParam().second, nullptr, 0) {}

: public MockChannelOptsTest,

public ::testing::WithParamInterface<int> {

public:

MockUDPChannelTest() : MockChannelOptsTest(1, GetParam(), false, nullptr, 0) {}

: public MockChannelOptsTest,

public ::testing::WithParamInterface<int> {

public:

MockTCPChannelTest() : MockChannelOptsTest(1, GetParam(), true, nullptr, 0) {}

HostEnt() : addrtype_(-1) {}

HostEnt(const struct hostent* hostent);

std::string name_;

std::vector<std::string> aliases_;

int addrtype_; // AF_INET or AF_INET6

std::vector<std::string> addrs_;

HostResult() : done_(false), status_(0), timeouts_(0) {}

// Whether the callback has been invoked.

bool done_;

// Explicitly provided result information.

int status_;

int timeouts_;

// Contents of the hostent structure, if provided.

HostEnt host_;

// Whether the callback has been invoked.

bool done_;

// Explicitly provided result information.

int status_;

int timeouts_;

std::vector<byte> data_;

// Whether the callback has been invoked.

bool done_;

// Explicitly provided result information.

int status_;

int timeouts_;

std::string node_;

std::string service_;

void operator() (ares_addrinfo *ptr) {

if (ptr) ares_freeaddrinfo(ptr);

}

AddrInfoResult() : done_(false), status_(-1), timeouts_(0) {}

// Whether the callback has been invoked.

bool done_;

// Explicitly provided result information.

int status_;

int timeouts_;

// Contents of the ares_addrinfo structure, if provided.

AddrInfo ai_;

public:

TransientDir(const std::string& dirname);

~TransientDir();

private:

std::string dirname_;

public:

TransientFile(const std::string &filename, const std::string &contents);

~TransientFile();

protected:

std::string filename_;

public:

TempFile(const std::string& contents);

const char* filename() const { return filename_.c_str(); }

{

char *buffer;

size_t buf_size;

if (name == NULL)

return -1;

if (value == NULL)

value = ""; /* For unset */

if (!overwrite && getenv(name) != NULL) {

return -1;

}

buf_size = strlen(name) + strlen(value) + 1 /* = */ + 1 /* NULL */;

buffer = (char *)malloc(buf_size);

_snprintf(buffer, buf_size, "%s=%s", name, value);

_putenv(buffer);

free(buffer);

return 0;

public:

EnvValue(const char *name, const char *value) : name_(name), restore_(false) {

char *original = getenv(name);

if (original) {

restore_ = true;

original_ = original;

}

setenv(name_.c_str(), value, 1);

}

~EnvValue() {

if (restore_) {

setenv(name_.c_str(), original_.c_str(), 1);

} else {

unsetenv(name_.c_str());

}

}

private:

std::string name_;

bool restore_;

std::string original_;

public:

ContainerFilesystem(NameContentList files, const std::string& mountpt);

~ContainerFilesystem();

std::string root() const { return rootdir_; };

std::string mountpt() const { return mountpt_; };

private:

void EnsureDirExists(const std::string& dir);

std::string rootdir_;

std::string mountpt_;

std::list<std::string> dirs_;

std::vector<std::unique_ptr<TransientFile>> files_;

public:

VirtualizeIO(ares_channel);

~VirtualizeIO();

static const ares_socket_functions default_functions;

private:

ares_channel channel_;