TEST(Dynamic, GetDefault) {
const auto s = make_long_string();
dynamic ds(s);
dynamic tmp(s);
dynamic d1 = dynamic::object("key1", s);
dynamic d2 = dynamic::object("key2", s);
dynamic d3 = dynamic::object("key3", s);
dynamic d4 = dynamic::object("key4", s);
// lvalue - lvalue
dynamic ayy("ayy");
EXPECT_EQ(ds, d1.getDefault("key1", ayy));
EXPECT_EQ(ds, d1.getDefault("key1", ayy));
EXPECT_EQ(ds, d1.getDefault("not-a-key", tmp));
EXPECT_EQ(ds, tmp);
// lvalue - rvalue
EXPECT_EQ(ds, d1.getDefault("key1", "ayy"));
EXPECT_EQ(ds, d1.getDefault("key1", "ayy"));
EXPECT_EQ(ds, d1.getDefault("not-a-key", std::move(tmp)));
EXPECT_NE(ds, tmp);
// rvalue - lvalue
tmp = s;
EXPECT_EQ(ds, std::move(d1).getDefault("key1", ayy));
EXPECT_NE(ds, d1["key1"]);
EXPECT_EQ(ds, std::move(d2).getDefault("not-a-key", tmp));
EXPECT_EQ(dynamic(dynamic::object("key2", s)), d2);
EXPECT_EQ(ds, tmp);
// rvalue - rvalue
EXPECT_EQ(ds, std::move(d3).getDefault("key3", std::move(tmp)));
EXPECT_NE(ds, d3["key3"]);
EXPECT_EQ(ds, tmp);
EXPECT_EQ(ds, std::move(d4).getDefault("not-a-key", std::move(tmp)));
EXPECT_EQ(dynamic(dynamic::object("key4", s)), d4);
EXPECT_NE(ds, tmp);
}
void WedgeProductInfo::parse(std::string data) {
try {
dynamic info = parseJson(data)[kInfo];
productInfo_.oem = folly::to<std::string>(info[kSysMfg].asString());
productInfo_.product = folly::to<std::string>(info[kProdName].asString());
productInfo_.serial = folly::to<std::string>(info[kSerialNum].asString());
productInfo_.mfgDate = folly::to<std::string>(info[kSysMfgDate].asString());
productInfo_.systemPartNumber =
folly::to<std::string>(info[kSysAmbPartNum].asString());
productInfo_.assembledAt = folly::to<std::string>(info[kAmbAt].asString());
productInfo_.pcbManufacturer =
folly::to<std::string>(info[kPcbMfg].asString());
productInfo_.assetTag =
folly::to<std::string>(info[kProdAssetTag].asString());
productInfo_.partNumber =
folly::to<std::string>(info[kProdPartNum].asString());
productInfo_.odmPcbPartNumber = folly::to<std::string>
(info[kOdmPcbPartNum].asString());
productInfo_.odmPcbSerial = folly::to<std::string>
(info[kOdmPcbSerialNum].asString());
productInfo_.fbPcbPartNumber = folly::to<std::string>
(info[kFbPcbPartNum].asString());
productInfo_.version = info[kVersion].asInt();
productInfo_.subVersion = info[kSubVersion].asInt();
productInfo_.productionState = info[kProductionState].asInt();
productInfo_.productVersion = info[kProdVersion].asInt();
productInfo_.bmcMac = folly::to<std::string>(info[kLocalMac].asString());
productInfo_.mgmtMac = folly::to<std::string>(info[kExtMacBase].asString());
auto macBase = MacAddress(info[kExtMacBase].asString()).u64HBO() + 1;
productInfo_.macRangeStart = MacAddress::fromHBO(macBase).toString();
productInfo_.macRangeSize = info[kExtMacSize].asInt() - 1;
} catch (const std::exception& err) {
LOG(ERROR) << err.what();
}
}
TEST(Json, SortKeys) {
folly::json::serialization_opts opts_on, opts_off;
opts_on.sort_keys = true;
opts_off.sort_keys = false;
dynamic value = dynamic::object
("foo", "bar")
("junk", 12)
("another", 32.2)
("a",
{
dynamic::object("a", "b")
("c", "d"),
12.5,
"Yo Dawg",
{ "heh" },
nullptr
}
)
;
std::string sorted_keys =
R"({"a":[{"a":"b","c":"d"},12.5,"Yo Dawg",["heh"],null],)"
R"("another":32.2,"foo":"bar","junk":12})";
EXPECT_EQ(value, parseJson(folly::json::serialize(value, opts_on)));
EXPECT_EQ(value, parseJson(folly::json::serialize(value, opts_off)));
EXPECT_EQ(sorted_keys, folly::json::serialize(value, opts_on));
}
TEST(Json, ParseNonStringKeys) {
// test string keys
EXPECT_EQ("a", parseJson("{\"a\":[]}").items().begin()->first.asString());
// check that we don't allow non-string keys as this violates the
// strict JSON spec (though it is emitted by the output of
// folly::dynamic with operator <<).
EXPECT_THROW(parseJson("{1:[]}"), std::runtime_error);
// check that we can parse colloquial JSON if the option is set
folly::json::serialization_opts opts;
opts.allow_non_string_keys = true;
auto val = parseJson("{1:[]}", opts);
EXPECT_EQ(1, val.items().begin()->first.asInt());
// test we can still read in strings
auto sval = parseJson("{\"a\":[]}", opts);
EXPECT_EQ("a", sval.items().begin()->first.asString());
// test we can read in doubles
auto dval = parseJson("{1.5:[]}", opts);
EXPECT_EQ(1.5, dval.items().begin()->first.asDouble());
}
TEST(MacAddress, toString) {
EXPECT_EQ("12:34:56:78:9a:bc",
MacAddress::fromHBO(0x123456789abc).toString());
EXPECT_EQ("12:34:56:78:9a:bc", MacAddress("12:34:56:78:9a:bc").toString());
EXPECT_EQ("01:23:45:67:89:ab", MacAddress("01-23-45-67-89-ab").toString());
EXPECT_EQ("01:23:45:67:89:ab", MacAddress("0123456789ab").toString());
}
int main(int argc, char* argv[]) {
gflags::ParseCommandLineFlags(&argc, &argv, true);
google::InitGoogleLogging(argv[0]);
google::InstallFailureSignalHandler();
std::vector<HTTPServer::IPConfig> IPs = {
{SocketAddress(FLAGS_ip, FLAGS_http_port, true), Protocol::HTTP},
{SocketAddress(FLAGS_ip, FLAGS_spdy_port, true), Protocol::SPDY},
};
if (FLAGS_threads <= 0) {
FLAGS_threads = sysconf(_SC_NPROCESSORS_ONLN);
CHECK(FLAGS_threads > 0);
}
HTTPServerOptions options;
options.threads = static_cast<size_t>(FLAGS_threads);
options.idleTimeout = std::chrono::milliseconds(60000);
options.shutdownOn = {SIGINT, SIGTERM};
options.enableContentCompression = true;
options.handlerFactories = RequestHandlerChain()
.addThen<HangmanHandlerFactory>()
.build();
HTTPServer server(std::move(options));
server.bind(IPs);
// Start HTTPServer mainloop in a separate thread
std::thread t([&] () {
server.start();
});
t.join();
return 0;
}
bool MmapFile::init() {
int fd = open(path_.c_str(), O_RDONLY);
if (fd < 0) {
Logger::Error(format("Unable to open {}: {}",
path_, folly::errnoStr(errno)).str());
return false;
}
struct stat fs;
if (fstat(fd, &fs) != 0) {
Logger::Error(format("Unable to fstat {}: {}",
path_, folly::errnoStr(errno)).str());
close(fd);
return false;
}
backing_fd_ = fd;
backing_mem_size_ = fs.st_size;
backing_mem_ = mmap(nullptr, backing_mem_size_, PROT_READ, MAP_PRIVATE,
backing_fd_, 0);
if (backing_mem_ == (void*) -1) {
Logger::Error(format("Unable to mmap {}: {}",
path_, folly::errnoStr(errno)).str());
close(backing_fd_);
return false;
}
backing_mem_end_ = (char*) backing_mem_ + backing_mem_size_;
read_ptr_ = static_cast<char*>(backing_mem_);
initialized_ = true;
return true;
}
TEST_F(FuseChannelTest, testDestroyWithPendingRequests) {
auto channel = createChannel();
auto completeFuture = performInit(channel.get());
// Send several lookup requests
auto id1 = fuse_.sendLookup(FUSE_ROOT_ID, "foobar");
auto id2 = fuse_.sendLookup(FUSE_ROOT_ID, "some_file.txt");
auto id3 = fuse_.sendLookup(FUSE_ROOT_ID, "main.c");
auto req1 = dispatcher_.waitForLookup(id1);
auto req2 = dispatcher_.waitForLookup(id2);
auto req3 = dispatcher_.waitForLookup(id3);
// Destroy the channel object
channel.reset();
// The completion future still should not be ready, since the lookup
// requests are still pending.
EXPECT_FALSE(completeFuture.isReady());
auto checkLookupResponse = [](const FakeFuse::Response& response,
uint64_t requestID,
fuse_entry_out expected) {
EXPECT_EQ(requestID, response.header.unique);
EXPECT_EQ(0, response.header.error);
EXPECT_EQ(
sizeof(fuse_out_header) + sizeof(fuse_entry_out), response.header.len);
EXPECT_EQ(
ByteRange(
reinterpret_cast<const uint8_t*>(&expected), sizeof(expected)),
ByteRange(response.body.data(), response.body.size()));
};
// Respond to the lookup requests
auto response1 = genRandomLookupResponse(9);
req1.promise.setValue(response1);
auto received = fuse_.recvResponse();
checkLookupResponse(received, id1, response1);
// We don't have to respond in order; respond to request 3 before 2
auto response3 = genRandomLookupResponse(19);
req3.promise.setValue(response3);
received = fuse_.recvResponse();
checkLookupResponse(received, id3, response3);
// The completion future still shouldn't be ready since there is still 1
// request outstanding.
EXPECT_FALSE(completeFuture.isReady());
auto response2 = genRandomLookupResponse(12);
req2.promise.setValue(response2);
received = fuse_.recvResponse();
checkLookupResponse(received, id2, response2);
// The completion future should be ready now that the last request
// is done.
EXPECT_TRUE(completeFuture.isReady());
std::move(completeFuture).get(kTimeout);
}
BENCHMARK(toJson, iters) {
dynamic something = parseJson(
"{\"old_value\":40,\"changed\":true,\"opened\":false,\"foo\":[1,2,3,4,5,6]}"
);
for (size_t i = 0; i < iters; i++) {
toJson(something);
}
}
TEST(Json, Produce) {
auto value = parseJson(R"( "f\"oo" )");
EXPECT_EQ(toJson(value), R"("f\"oo")");
value = parseJson("\"Control code: \001 \002 \x1f\"");
EXPECT_EQ(toJson(value), R"("Control code: \u0001 \u0002 \u001f")");
// We're not allowed to have non-string keys in json.
EXPECT_THROW(toJson(dynamic::object("abc", "xyz")(42.33, "asd")),
std::runtime_error);
}
TEST(Json, Unicode) {
auto val = parseJson("\"I \u2665 UTF-8\"");
EXPECT_EQ("I \u2665 UTF-8", val.asString());
val = parseJson("\"I \\u2665 UTF-8\"");
EXPECT_EQ("I \u2665 UTF-8", val.asString());
val = parseJson("\"I \U0001D11E playing in G-clef\"");
EXPECT_EQ("I \U0001D11E playing in G-clef", val.asString());
val = parseJson("\"I \\uD834\\uDD1E playing in G-clef\"");
EXPECT_EQ("I \U0001D11E playing in G-clef", val.asString());
}
std::unique_ptr<UnicastRoute>
makeUnicastRoute(std::string prefixStr, std::string nxtHop,
AdminDistance distance=AdminDistance::MAX_ADMIN_DISTANCE) {
std::vector<std::string> vec;
folly::split("/", prefixStr, vec);
EXPECT_EQ(2, vec.size());
auto nr = std::make_unique<UnicastRoute>();
nr->dest.ip = toBinaryAddress(IPAddress(vec.at(0)));
nr->dest.prefixLength = folly::to<uint8_t>(vec.at(1));
nr->nextHopAddrs.push_back(toBinaryAddress(IPAddress(nxtHop)));
nr->adminDistance = distance;
nr->__isset.adminDistance = true;
return nr;
}
TEST(Dynamic, At) {
const dynamic cd = dynamic::object("key1", make_long_string());
dynamic dd = dynamic::object("key1", make_long_string());
dynamic md = dynamic::object("key1", make_long_string());
dynamic ds(make_long_string());
EXPECT_EQ(ds, cd.at("key1"));
EXPECT_EQ(ds, cd.at("key1"));
dd.at("key1").getString() += " hello";
EXPECT_EQ(dynamic(make_long_string() + " hello"), dd.at("key1"));
EXPECT_EQ(dynamic(make_long_string() + " hello"), dd.at("key1"));
EXPECT_EQ(ds, std::move(md).at("key1"));
EXPECT_NE(ds, md.at("key1"));
}
TEST(make_array, deduced_common_type) {
auto arr = make_array(1.0, 2.5f, 3, 4, 5);
static_assert(
is_same<typename decltype(arr)::value_type, double>::value,
"Wrong array type");
EXPECT_EQ(arr.size(), 5);
}
TEST(OpenRTB, DeviceTest) {
dynamic deviceObj = parseJson(readFile("testdata/device.json"));
Device device;
device.deserialize(deviceObj);
std::function<void()> checkFunction = [&](){
EXPECT_EQ(device.ip, deviceObj.at("ip").asString().toStdString());
EXPECT_EQ(device.language.get(), deviceObj.at("language").asString().toStdString());
EXPECT_EQ(device.carrier.get(), deviceObj.at("carrier").asString().toStdString());
EXPECT_EQ(device.model.get(), deviceObj.at("model").asString().toStdString());
EXPECT_EQ(device.os.get(), deviceObj.at("os").asString().toStdString());
EXPECT_EQ(device.osv.get(), deviceObj.at("osv").asString().toStdString());
EXPECT_EQ(device.make.get(), deviceObj.at("make").asString().toStdString());
//geo
EXPECT_EQ(device.geo.get().city, deviceObj.at("geo").at("city").asString().toStdString());
EXPECT_EQ(device.geo.get().country, deviceObj.at("geo").at("country").asString().toStdString());
EXPECT_EQ(device.geo.get().metro, deviceObj.at("geo").at("metro").asString().toStdString());
EXPECT_EQ(device.geo.get().region, deviceObj.at("geo").at("region").asString().toStdString());
EXPECT_EQ(device.geo.get().zip, deviceObj.at("geo").at("zip").asString().toStdString());
};
checkFunction();
//serialize object
deviceObj = device.serialize();
//check again with new serialized device object
checkFunction();
}
// Using ScopeGuard to invoke a std::function
BENCHMARK(scope_guard_std_function, iters) {
std::function<void()> fn(doNothing);
for (size_t n = 0; n < iters; ++n) {
auto g = makeGuard(fn);
(void)g;
}
}
TEST(GitBlob, testDeserializeManaged) {
string blobHash("3a8f8eb91101860fd8484154885838bf322964d0");
Hash hash(blobHash);
string contents("{\n \"breakConfig\": true\n}\n");
auto buf = IOBuf::create(1024);
folly::io::Appender appender(buf.get(), 0);
appender.printf("blob %zu", contents.size());
appender.write<uint8_t>(0);
appender.push(StringPiece(contents));
// Sanity check that we are the only user of the newly-created IOBuf
EXPECT_FALSE(buf->isShared()) << "newly created IOBuf should not be shared";
auto blob = deserializeGitBlob(hash, buf.get());
EXPECT_EQ(hash, blob->getHash());
EXPECT_TRUE(buf->isShared())
<< "deserializeGitBlob() should return a blob that shares the same "
<< "IOBuf data, instead of copying it";
EXPECT_EQ(contents, StringPiece{blob->getContents().clone()->coalesce()});
// Make sure the blob contents are still valid after freeing
// our copy of the IOBuf
buf.reset();
EXPECT_EQ(contents, StringPiece{blob->getContents().clone()->coalesce()});
}
// Test deserializing from an unmanaged IOBuf, which doesn't control the
// lifetime of the underlying data
TEST(GitBlob, testDeserializeUnmanaged) {
string blobHash("3a8f8eb91101860fd8484154885838bf322964d0");
Hash hash(blobHash);
string contents("{\n \"breakConfig\": true\n}\n");
auto gitBlobObjectStr = folly::to<string>(string("blob 26\x00", 8), contents);
folly::ByteRange gitBlobObject = folly::StringPiece{gitBlobObjectStr};
EXPECT_EQ(blobHash, Hash::sha1(gitBlobObject).toString())
<< "SHA-1 of contents should match key";
IOBuf buf(IOBuf::WRAP_BUFFER, gitBlobObject);
auto blob = deserializeGitBlob(hash, &buf);
EXPECT_EQ(hash, blob->getHash());
EXPECT_FALSE(blob->getContents().isShared())
<< "deserializeGitBlob() must make a copy of the buffer given "
<< "an unmanaged IOBuf as input";
EXPECT_EQ(contents, StringPiece{blob->getContents().clone()->coalesce()});
// Make sure the blob contents are still valid after freeing our string data.
{
std::string empty;
gitBlobObjectStr.swap(empty);
buf = IOBuf();
}
EXPECT_EQ(contents, StringPiece{blob->getContents().clone()->coalesce()});
}
StringPiece sfpString(const uint8_t* buf, size_t offset, size_t len) {
const uint8_t* start = buf + offset;
while (len > 0 && start[len - 1] == ' ') {
--len;
}
return StringPiece(reinterpret_cast<const char*>(start), len);
}
TEST(OpenRTB, AppTest) {
dynamic appObj = parseJson(readFile("testdata/app.json"));
App app;
app.deserialize(appObj);
std::function<void()> checkFunction = [&](){
EXPECT_EQ(app.id, appObj.at("id").asString().toStdString());
EXPECT_EQ(app.name.get(), appObj.at("name").asString().toStdString());
dynamic catArr = {};
for(auto elem : app.cat.get()) {
catArr.push_back(elem);
}
EXPECT_EQ(catArr, appObj.at("cat"));
EXPECT_EQ(app.publisher.get().id, appObj.at("publisher").at("id").asString().toStdString());
EXPECT_EQ(app.publisher.get().domain, appObj.at("publisher").at("domain").asString().toStdString());
EXPECT_EQ(app.publisher.get().name, appObj.at("publisher").at("name").asString().toStdString());
};
checkFunction();
appObj = app.serialize();
checkFunction();
}
TEST(Dynamic, Brackets) {
const dynamic cd = dynamic::object("key1", make_long_string());
dynamic dd = dynamic::object("key1", make_long_string());
dynamic md = dynamic::object("key1", make_long_string());
dynamic ds(make_long_string());
EXPECT_EQ(ds, cd["key1"]);
EXPECT_EQ(ds, cd["key1"]);
dd["key1"].getString() += " hello";
EXPECT_EQ(dynamic(make_long_string() + " hello"), dd["key1"]);
EXPECT_EQ(dynamic(make_long_string() + " hello"), dd["key1"]);
EXPECT_EQ(ds, std::move(md)["key1"]);
EXPECT_NE(ds, md["key1"]);
}
TEST(ArpTest, ArpTableSerialization) {
auto sw = setupSwitch();
VlanID vlanID(1);
IPAddressV4 senderIP = IPAddressV4("10.0.0.1");
IPAddressV4 targetIP = IPAddressV4("10.0.0.2");
EXPECT_HW_CALL(sw, stateChanged(_)).Times(0);
auto vlan = sw->getState()->getVlans()->getVlanIf(vlanID);
EXPECT_NE(vlan, nullptr);
auto arpTable = vlan->getArpTable();
EXPECT_NE(arpTable, nullptr);
EXPECT_EQ(arpTable->hasPendingEntries(), false);
auto serializedArpTable = arpTable->toFollyDynamic();
auto unserializedArpTable = arpTable->fromFollyDynamic(serializedArpTable);
EXPECT_EQ(unserializedArpTable->hasPendingEntries(), false);
waitForStateUpdates(sw.get());
// Cache the current stats
CounterCache counters(sw.get());
testSendArpRequest(sw, vlanID, senderIP, targetIP);
waitForStateUpdates(sw.get());
counters.update();
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.request.tx.sum", 1);
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.request.rx.sum", 0);
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.reply.tx.sum", 0);
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.reply.rx.sum", 0);
vlan = sw->getState()->getVlans()->getVlanIf(vlanID);
EXPECT_NE(vlan, nullptr);
arpTable = vlan->getArpTable();
EXPECT_NE(arpTable, nullptr);
EXPECT_EQ(arpTable->hasPendingEntries(), true);
serializedArpTable = arpTable->toFollyDynamic();
unserializedArpTable = arpTable->fromFollyDynamic(serializedArpTable);
// Pending flag should still be set
EXPECT_EQ(unserializedArpTable->hasPendingEntries(), true);
// Should also see a pending entry
auto entry = sw->getState()->getVlans()->getVlanIf(vlanID)->getArpTable()
->getEntryIf(targetIP);
EXPECT_NE(sw, nullptr);
}
TEST(make_array, deduce_everything) {
auto arr = make_array(string{"foo"}, string{"bar"});
static_assert(
is_same<typename decltype(arr)::value_type, std::string>::value,
"Wrong array type");
EXPECT_EQ(arr.size(), 2);
EXPECT_EQ(arr[1], "bar");
}
TEST(Dynamic, GetPtr) {
dynamic array = { 1, 2, "three" };
EXPECT_TRUE(array.get_ptr(0));
EXPECT_FALSE(array.get_ptr(3));
EXPECT_EQ(dynamic("three"), *array.get_ptr(2));
const dynamic& carray = array;
EXPECT_EQ(dynamic("three"), *carray.get_ptr(2));
dynamic object = dynamic::object("one", 1)("two", 2);
EXPECT_TRUE(object.get_ptr("one"));
EXPECT_FALSE(object.get_ptr("three"));
EXPECT_EQ(dynamic(2), *object.get_ptr("two"));
*object.get_ptr("one") = 11;
EXPECT_EQ(dynamic(11), *object.get_ptr("one"));
const dynamic& cobject = object;
EXPECT_EQ(dynamic(2), *cobject.get_ptr("two"));
}
TEST(ArpTest, PendingArpCleanup) {
std::chrono::seconds arpTimeout(1);
std::chrono::seconds arpAgerInterval(1);
auto sw = setupSwitch(arpTimeout, arpAgerInterval);
VlanID vlanID(1);
IPAddressV4 senderIP = IPAddressV4("10.0.0.1");
IPAddressV4 targetIP = IPAddressV4("10.0.0.2");
// Cache the current stats
CounterCache counters(sw.get());
testSendArpRequest(sw, vlanID, senderIP, targetIP);
waitForStateUpdates(sw.get());
counters.update();
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.request.tx.sum", 1);
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.request.rx.sum", 0);
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.reply.tx.sum", 0);
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.reply.rx.sum", 0);
// Should see a pending entry now
auto entry = sw->getState()->getVlans()->getVlanIf(vlanID)->getArpTable()
->getEntryIf(targetIP);
EXPECT_NE(entry, nullptr);
EXPECT_EQ(entry->isPending(), true);
// Send an Arp request for a different neighbor
IPAddressV4 targetIP2 = IPAddressV4("10.0.0.3");
testSendArpRequest(sw, vlanID, senderIP, targetIP2);
counters.update();
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.request.tx.sum", 1);
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.request.rx.sum", 0);
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.reply.tx.sum", 0);
counters.checkDelta(SwitchStats::kCounterPrefix + "arp.reply.rx.sum", 0);
// Should see another pending entry now
waitForStateUpdates(sw.get());
entry = sw->getState()->getVlans()->getVlanIf(vlanID)->getArpTable()
->getEntryIf(targetIP2);
EXPECT_NE(entry, nullptr);
EXPECT_EQ(entry->isPending(), true);
}
TEST(Dynamic, FormattedIO) {
std::ostringstream out;
dynamic doubl = 123.33;
dynamic dint = 12;
out << "0x" << std::hex << ++dint << ' ' << std::setprecision(1)
<< doubl << '\n';
EXPECT_EQ(out.str(), "0xd 1e+02\n");
out.str("");
dynamic arrr = { 1, 2, 3 };
out << arrr;
EXPECT_EQ(out.str(), "[1,2,3]");
out.str("");
dynamic objy = dynamic::object("a", 12);
out << objy;
EXPECT_EQ(out.str(), R"({"a":12})");
out.str("");
dynamic objy2 = { objy, dynamic::object(12, "str"),
dynamic::object(true, false) };
out << objy2;
EXPECT_EQ(out.str(), R"([{"a":12},{12:"str"},{true:false}])");
}
TEST(Dynamic, GetSetDefaultTest) {
dynamic d1 = dynamic::object("foo", "bar");
EXPECT_EQ(d1.getDefault("foo", "baz"), "bar");
EXPECT_EQ(d1.getDefault("quux", "baz"), "baz");
dynamic d2 = dynamic::object("foo", "bar");
EXPECT_EQ(d2.setDefault("foo", "quux"), "bar");
d2.setDefault("bar", dynamic({})).push_back(42);
EXPECT_EQ(d2["bar"][0], 42);
dynamic d3 = dynamic::object, empty = dynamic::object;
EXPECT_EQ(d3.getDefault("foo"), empty);
d3.setDefault("foo")["bar"] = "baz";
EXPECT_EQ(d3["foo"]["bar"], "baz");
// we do not allow getDefault/setDefault on arrays
dynamic d4 = dynamic({});
EXPECT_ANY_THROW(d4.getDefault("foo", "bar"));
EXPECT_ANY_THROW(d4.setDefault("foo", "bar"));
}
virtual void process(std::unique_ptr<ResponseChannel::Request> req,
std::unique_ptr<folly::IOBuf> buf,
protocol::PROTOCOL_TYPES protType,
Cpp2RequestContext* context,
async::TEventBase* eb,
concurrency::ThreadManager* tm) {
assert(iface_);
auto reqd = makeMoveWrapper(std::move(req));
auto bufd = makeMoveWrapper(std::move(buf));
tm->add(FunctionRunner::create([=] () mutable {
(*bufd)->coalesce();
uint64_t resp;
char* data;
iface_->process(
(*reqd).release(), eb, (*bufd)->writableData(),
(*bufd)->length(), protType);
}));
}
TEST(SocketAddress, SetFromHostname) {
// hopefully "localhost" is resolvable on any system that will run the tests
EXPECT_THROW(SocketAddress("localhost", 80), std::runtime_error);
SocketAddress addr("localhost", 80, true);
SocketAddress addr2;
EXPECT_THROW(addr2.setFromIpPort("localhost", 0), std::runtime_error);
addr2.setFromHostPort("localhost", 0);
}
bool CacheSaver::writeString(const string& str) const {
if (!writeUInt64(str.length())) {
return false;
}
ssize_t write_len = str.length();
always_assert(write_len >= 0);
ssize_t ret = writeFull(fd_, (const void*) str.data(), write_len);
if (ret < 0) {
Logger::Error(format("Unable to write string: {}",
folly::errnoStr(errno)).str());
return false;
}
return ret == write_len;
}
static fbstring formatDocComment(const fbstring& comment) {
const char *p = comment.c_str();
const char *s;
const char *e = p + comment.size();
fbstring ret("/**\n");
while ((s = strchr(p, '\n'))) {
ret += " *";
if ((s - p) > 1) {
ret += " " + fbstring(p, (s - p));
}
ret += "\n";
p = s + 1;
}
if (p < e) {
ret += " * " + fbstring(p) + "\n";
}
return ret + " */";
}
