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 + " */"; }