Gitiles
Code Review Sign In
review.jami.net / dhtnet / c631a832d375b8848ddf75b4314cc6decb460d5e / . / tests / connectionManager.cpp
blob: 01cd91a660b846909f05f7417b021adf9ce629b1 [file] [log] [blame]
/*
* Copyright (C) 2004-2023 Savoir-faire Linux Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <iostream>
#include <filesystem>
#include <opendht/log.h>
#include <cppunit/TestAssert.h>
#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include <asio/executor_work_guard.hpp>
#include <asio/io_context.hpp>
#include <condition_variable>
#include "connectionmanager.h"
#include "multiplexed_socket.h"
#include "test_runner.h"
#include "certstore.h"
using namespace std::literals::chrono_literals;
namespace dhtnet {
namespace test {
struct ConnectionHandler {
dht::crypto::Identity id;
std::shared_ptr<Logger> logger;
std::shared_ptr<tls::CertificateStore> certStore;
std::shared_ptr<dht::DhtRunner> dht;
std::shared_ptr<ConnectionManager> connectionManager;
std::shared_ptr<asio::io_context> ioContext;
std::thread ioContextRunner;
};
class ConnectionManagerTest : public CppUnit::TestFixture
{
public:
ConnectionManagerTest() {}
~ConnectionManagerTest() { }
static std::string name() { return "ConnectionManager"; }
void setUp();
void tearDown();
std::unique_ptr<ConnectionHandler> alice;
std::unique_ptr<ConnectionHandler> bob;
//Create a lock to be used in the test units
std::mutex mtx;
std::shared_ptr<asio::io_context> ioContext;
std::thread ioContextRunner;
std::shared_ptr<Logger> logger;
std::unique_ptr<IceTransportFactory> factory;
private:
std::unique_ptr<ConnectionHandler> setupHandler(const std::string& name);
void testConnectDevice();
// void testAcceptConnection();
// void testMultipleChannels();
// void testMultipleChannelsOneDeclined();
// void testMultipleChannelsSameName();
// void testDeclineConnection();
// void testSendReceiveData();
// void testAcceptsICERequest();
// void testDeclineICERequest();
// void testChannelRcvShutdown();
// void testChannelSenderShutdown();
// void testCloseConnectionWith();
// void testShutdownCallbacks();
// void testFloodSocket();
// void testDestroyWhileSending();
// void testIsConnecting();
// void testCanSendBeacon();
// void testCannotSendBeacon();
// void testConnectivityChangeTriggerBeacon();
// void testOnNoBeaconTriggersShutdown();
// void testShutdownWhileNegotiating();
CPPUNIT_TEST_SUITE(ConnectionManagerTest);
// CPPUNIT_TEST(testAcceptsICERequest);
// CPPUNIT_TEST(testDeclineICERequest);
CPPUNIT_TEST(testConnectDevice);
// CPPUNIT_TEST(testIsConnecting);
// CPPUNIT_TEST(testAcceptConnection);
// CPPUNIT_TEST(testDeclineConnection);
// CPPUNIT_TEST(testMultipleChannels);
// CPPUNIT_TEST(testMultipleChannelsOneDeclined);
// CPPUNIT_TEST(testMultipleChannelsSameName);
// CPPUNIT_TEST(testSendReceiveData);
// CPPUNIT_TEST(testChannelRcvShutdown);
// CPPUNIT_TEST(testChannelSenderShutdown);
// CPPUNIT_TEST(testCloseConnectionWith);
// CPPUNIT_TEST(testShutdownCallbacks);
// CPPUNIT_TEST(testFloodSocket);
// CPPUNIT_TEST(testDestroyWhileSending);
// CPPUNIT_TEST(testCanSendBeacon);
// CPPUNIT_TEST(testCannotSendBeacon);
// CPPUNIT_TEST(testConnectivityChangeTriggerBeacon);
// CPPUNIT_TEST(testOnNoBeaconTriggersShutdown);
// CPPUNIT_TEST(testShutdownWhileNegotiating);
CPPUNIT_TEST_SUITE_END();
};
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(ConnectionManagerTest, ConnectionManagerTest::name());
std::unique_ptr<ConnectionHandler>
ConnectionManagerTest::setupHandler(const std::string& name) {
auto h = std::make_unique<ConnectionHandler>();
auto ca = dht::crypto::generateIdentity("ca");
h->id = dht::crypto::generateIdentity(name, ca);
h->logger = logger;
h->certStore = std::make_shared<tls::CertificateStore>(name, h->logger);
h->ioContext = std::make_shared<asio::io_context>();
h->ioContextRunner = std::thread([context = h->ioContext]() {
try {
auto work = asio::make_work_guard(*context);
context->run();
} catch (const std::exception& ex) {
//print the error;
}
});
dht::DhtRunner::Config dhtConfig;
dhtConfig.dht_config.id = h->id;
dhtConfig.threaded = true;
dht::DhtRunner::Context dhtContext;
dhtContext.certificateStore = [c=h->certStore](const dht::InfoHash& pk_id) {
std::vector<std::shared_ptr<dht::crypto::Certificate>> ret;
if (auto cert = c->getCertificate(pk_id.toString()))
ret.emplace_back(std::move(cert));
return ret;
};
dhtContext.logger = h->logger;
h->dht = std::make_shared<dht::DhtRunner>();
h->dht->run(dhtConfig, std::move(dhtContext));
h->dht->bootstrap("127.0.0.1:3355");
auto config = std::make_shared<ConnectionManager::Config>();
config->dht = h->dht;
config->id = h->id;
config->ioContext = h->ioContext;
config->factory = factory.get();
config->logger = logger;
config->certStore = h->certStore.get();
std::filesystem::path currentPath = std::filesystem::current_path();
std::filesystem::path tempDirPath = currentPath / "temp";
config->cachePath = tempDirPath.string();
h->connectionManager = std::make_shared<ConnectionManager>(config);
h->connectionManager->onICERequest([](const DeviceId&) {
return true;
});
return h;
}
void
ConnectionManagerTest::setUp()
{
logger = dht::log::getStdLogger();
logger->debug("Using PJSIP version {} for {}", pj_get_version(), PJ_OS_NAME);
logger->debug("Using GnuTLS version {}", gnutls_check_version(nullptr));
logger->debug("Using OpenDHT version {}", dht::version());
ioContext = std::make_shared<asio::io_context>();
ioContextRunner = std::thread([context = ioContext]() {
try {
auto work = asio::make_work_guard(*context);
context->run();
} catch (const std::exception& ex) {
//print the error;
}
});
factory = std::make_unique<IceTransportFactory>(logger);
alice = setupHandler("alice");
bob = setupHandler("bob");
}
/*
auto identifier = bobId.first->getPublicKey().getLongId();
auto identifier = bobId.second->getLongId();
auto identifier = bobId.second->getPublicKey().getLongId();
*/
void
ConnectionManagerTest::tearDown()
{
//wait_for_removal_of({aliceId, bobId}); //?????????????????????????????????
ioContext->stop();
if (ioContextRunner.joinable())
ioContextRunner.join();
}
/*
void
ConnectionManagerTest::testConnectDevice()
{
auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
std::mutex mtx;
std::unique_lock<std::mutex> lk {mtx};
std::condition_variable cv, cvReceive;
bool successfullyConnected = false;
bool successfullyReceive = false;
bobAccount->connectionManager().onChannelRequest(
[&successfullyReceive, &cvReceive](const std::shared_ptr<dht::crypto::Certificate>&,
const std::string& name) {
successfullyReceive = name == "git://*";
cvReceive.notify_one();
return true;
});
aliceAccount->connectionManager().connectDevice(bobDeviceId,
"git://*",
[&](std::shared_ptr<ChannelSocket> socket,
const DeviceId&) {
if (socket) {
successfullyConnected = true;
}
cv.notify_one();
});
CPPUNIT_ASSERT(cvReceive.wait_for(lk, 60s, [&] { return successfullyReceive; }));
CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return successfullyConnected; }));
}
*/
void
ConnectionManagerTest::testConnectDevice()
{
std::unique_lock<std::mutex> lock {mtx};
std::condition_variable bobConVar;
bool isBobRecvChanlReq = false;
alice->connectionManager->onDhtConnected(alice->id.first->getPublicKey());
bob->connectionManager->onDhtConnected(bob->id.first->getPublicKey());
bob->connectionManager->onChannelRequest([&isBobRecvChanlReq, &bobConVar]
(const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name)
{
isBobRecvChanlReq = name == "dumyName";
bobConVar.notify_one();
return true;
});
std::condition_variable alicConVar;
bool isAlicConnected = false;
auto conctDevicCalBack = [&](std::shared_ptr<ChannelSocket> socket, const DeviceId&) {
if (socket) { isAlicConnected = true; }
alicConVar.notify_one();
};
alice->connectionManager->connectDevice(bob->id.second, "dumyName", conctDevicCalBack);
//Step 4: to check if Alice connected to Bob?
CPPUNIT_ASSERT(alicConVar.wait_for(lock, 60s, [&] { return isAlicConnected; }));
}
// /*
// void
// ConnectionManagerTest::testAcceptConnection()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// bobAccount->connectionManager().onChannelRequest(
// [&successfullyReceive](const std::shared_ptr<dht::crypto::Certificate>&,
// const std::string& name) {
// successfullyReceive = name == "git://*";
// return true;
// });
// bobAccount->connectionManager().onConnectionReady(
// [&receiverConnected](const DeviceId&,
// const std::string& name,
// std::shared_ptr<ChannelSocket> socket) {
// receiverConnected = socket && (name == "git://*");
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return successfullyReceive && successfullyConnected && receiverConnected;
// }));
// }
// */
// void
// ConnectionManagerTest::testAcceptConnection()
// {
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// auto chanlReqCalBack = [&successfullyReceive]
// (const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name)
// {
// successfullyReceive = name == "dumyname";
// return true;
// };
// bobConMngr.onChannelRequest(chanlReqCalBack);
// bool receiverConnected = false;
// auto conctReadyCalBack =[&receiverConnected]
// (const DeviceId& deviceId, const std::string& name, std::shared_ptr<ChannelSocket> socket)
// {
// receiverConnected = socket && (name == "dumyname");
// };
// bobConMngr.onConnectionReady(conctReadyCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket)
// successfullyConnected = true;
// cv.notify_one();
// };
// alicConMngr.connectDevice(bobDevicId, "dumyname", conctDevicCalBack);
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return successfullyReceive && successfullyConnected && receiverConnected;
// }));
// }
// /*
// void
// ConnectionManagerTest::testDeclineConnection()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// bobAccount->connectionManager().onChannelRequest(
// [&successfullyReceive](const std::shared_ptr<dht::crypto::Certificate>&,
// const std::string&) {
// successfullyReceive = true;
// return false;
// });
// bobAccount->connectionManager().onConnectionReady(
// [&receiverConnected](const DeviceId&,
// const std::string&,
// std::shared_ptr<ChannelSocket> socket) {
// if (socket)
// receiverConnected = true;
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// cv.wait_for(lk, 30s);
// CPPUNIT_ASSERT(successfullyReceive);
// CPPUNIT_ASSERT(!successfullyConnected);
// CPPUNIT_ASSERT(!receiverConnected);
// }
// */
// void
// ConnectionManagerTest::testDeclineConnection()
// {
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// auto chanlReqCalBack = [&successfullyReceive]
// (const std::shared_ptr<dht::crypto::Certificate>&, const std::string&)
// {
// successfullyReceive = true;
// return false; //this is the point??????????????????????????????????????????????????????
// };
// bobConMngr.onChannelRequest(chanlReqCalBack);
// auto conctReadyCalBack =[&receiverConnected]
// (const DeviceId&, const std::string&, std::shared_ptr<ChannelSocket> socket)
// {
// if (socket)
// receiverConnected = true;
// };
// bobConMngr.onConnectionReady(conctReadyCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket)
// successfullyConnected = true;
// cv.notify_one();
// };
// alicConMngr.connectDevice(bobDevicId, "dumyname", conctDevicCalBack);
// cv.wait_for(lk, 30s);
// CPPUNIT_ASSERT(successfullyReceive);
// CPPUNIT_ASSERT(!successfullyConnected);
// CPPUNIT_ASSERT(!receiverConnected);
// }
// /*
// void
// ConnectionManagerTest::testMultipleChannels()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyConnected2 = false;
// int receiverConnected = 0;
// bobAccount->connectionManager().onChannelRequest(
// [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onConnectionReady(
// [&receiverConnected](const DeviceId&,
// const std::string&,
// std::shared_ptr<ChannelSocket> socket) {
// if (socket)
// receiverConnected += 1;
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "sip://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected2 = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return successfullyConnected && successfullyConnected2 && receiverConnected == 2;
// }));
// CPPUNIT_ASSERT(aliceAccount->connectionManager().activeSockets() == 1);
// }
// */
// void
// ConnectionManagerTest::testMultipleChannels()
// {
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyConnected2 = false;
// int receiverConnected = 0;
// auto chanlReqCalBack = []
// (const std::shared_ptr<dht::crypto::Certificate>&, const std::string&)
// {
// return true;
// };
// bobConMngr.onChannelRequest(chanlReqCalBack);
// auto conctReadyCalBack =[&receiverConnected]
// (const DeviceId&, const std::string&, std::shared_ptr<ChannelSocket> socket)
// {
// if (socket)
// receiverConnected += 1;
// };
// bobConMngr.onConnectionReady(conctReadyCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket)
// successfullyConnected = true;
// cv.notify_one();
// };
// alicConMngr.connectDevice(bobDevicId, "git://*", conctDevicCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket)
// successfullyConnected2 = true;
// cv.notify_one();
// };
// alicConMngr.connectDevice(bobDevicId, "sip://*", conctDevicCalBack);
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return successfullyConnected && successfullyConnected2 && receiverConnected == 2;
// }));
// CPPUNIT_ASSERT(alicConMngr.activeSockets() == 1);
// }
// /*void
// ConnectionManagerTest::testMultipleChannelsOneDeclined()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyNotConnected = false;
// bool successfullyConnected2 = false;
// int receiverConnected = 0;
// bobAccount->connectionManager().onChannelRequest(
// [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name) {
// if (name == "git://*")
// return false;
// return true;
// });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId&, const std::string&, std::shared_ptr<ChannelSocket> socket) {
// if (socket)
// receiverConnected += 1;
// cv.notify_one();
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (!socket)
// successfullyNotConnected = true;
// cv.notify_one();
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "sip://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket)
// successfullyConnected2 = true;
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return successfullyNotConnected && successfullyConnected2 && receiverConnected == 1;
// }));
// CPPUNIT_ASSERT(aliceAccount->connectionManager().activeSockets() == 1);
// }
// */
// void
// ConnectionManagerTest::testMultipleChannelsOneDeclined()
// {
// std::condition_variable cv;
// bool successfullyNotConnected = false;
// bool successfullyConnected2 = false;
// int receiverConnected = 0;
// auto chanlReqCalBack = []
// (const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name)
// {
// if (name == "git://*")
// return false;
// return true;
// };
// bobConMngr.onChannelRequest(chanlReqCalBack);
// auto conctReadyCalBack =[&receiverConnected]
// (const DeviceId&, const std::string&, std::shared_ptr<ChannelSocket> socket)
// {
// if (socket)
// receiverConnected += 1;
// };
// bobConMngr.onConnectionReady(conctReadyCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket)
// successfullyConnected = true;
// cv.notify_one();
// };
// alicConMngr.connectDevice(bobDevicId, "git://*", conctDevicCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket)
// successfullyConnected2 = true;
// cv.notify_one();
// };
// alicConMngr.connectDevice(bobDevicId, "sip://*", conctDevicCalBack);
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return successfullyNotConnected && successfullyConnected2 && receiverConnected == 1;
// }));
// CPPUNIT_ASSERT(aliceAccount->connectionManager().activeSockets() == 1);
// }
// /*
// void
// ConnectionManagerTest::testMultipleChannelsSameName()
// {
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyConnected2 = false;
// int receiverConnected = 0;
// bobAccount->connectionManager().onChannelRequest(
// [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onConnectionReady(
// [&receiverConnected](const DeviceId&,
// const std::string&,
// std::shared_ptr<ChannelSocket> socket) {
// if (socket)
// receiverConnected += 1;
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// // We can open two sockets with the same name, it will be two different channel
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected2 = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return successfullyConnected && successfullyConnected2 && receiverConnected == 2;
// }));
// }
// */
// void
// ConnectionManagerTest::testMultipleChannelsSameName()
// {
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyConnected2 = false;
// int receiverConnected = 0;
// auto chanlReqCalBack = []
// (const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name)
// {
// return true;
// };
// bobConMngr.onChannelRequest(chanlReqCalBack);
// auto conctReadyCalBack =[&receiverConnected]
// (const DeviceId&, const std::string&, std::shared_ptr<ChannelSocket> socket)
// {
// if (socket)
// receiverConnected += 1;
// };
// bobConMngr.onConnectionReady(conctReadyCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket)
// successfullyConnected = true;
// cv.notify_one();
// };
// alicConMngr.connectDevice(bobDevicId, "git://*", conctDevicCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket)
// successfullyConnected2 = true;
// cv.notify_one();
// };
// alicConMngr.connectDevice(bobDevicId, "sip://*", conctDevicCalBack);
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return successfullyConnected && successfullyConnected2 && receiverConnected == 2;
// }));
// }
// //Explain this more
// /*
// void
// ConnectionManagerTest::testSendReceiveData()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// std::atomic_int events(0);
// bool successfullyConnected = false, successfullyConnected2 = false, successfullyReceive = false,
// receiverConnected = false;
// const uint8_t buf_other[] = {0x64, 0x65, 0x66, 0x67};
// const uint8_t buf_test[] = {0x68, 0x69, 0x70, 0x71};
// bool dataOk = false, dataOk2 = false;
// bobAccount->connectionManager().onChannelRequest(
// [&successfullyReceive](const std::shared_ptr<dht::crypto::Certificate>&,
// const std::string&) {
// successfullyReceive = true;
// return true;
// });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId&, const std::string& name, std::shared_ptr<ChannelSocket> socket) {
// if (socket && (name == "test" || name == "other")) {
// receiverConnected = true;
// std::error_code ec;
// auto res = socket->waitForData(std::chrono::milliseconds(5000), ec);
// if (res == 4) {
// uint8_t buf[4];
// socket->read(&buf[0], 4, ec);
// if (name == "test")
// dataOk = std::equal(std::begin(buf), std::end(buf), std::begin(buf_test));
// else
// dataOk2 = std::equal(std::begin(buf), std::end(buf), std::begin(buf_other));
// events++;
// cv.notify_one();
// }
// }
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "test",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// std::error_code ec;
// socket->write(&buf_test[0], 4, ec);
// }
// events++;
// cv.notify_one();
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "other",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected2 = true;
// std::error_code ec;
// socket->write(&buf_other[0], 4, ec);
// }
// events++;
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return events == 4 && successfullyReceive && successfullyConnected && successfullyConnected2
// && dataOk && dataOk2;
// }));
// }
// */
// void
// ConnectionManagerTest::testSendReceiveData()
// {
// std::condition_variable cv;
// std::atomic_int events(0);
// bool successfullyConnected = false;
// bool successfullyConnected2 = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// const uint8_t buf_other[] = {0x64, 0x65, 0x66, 0x67};
// const uint8_t buf_test[] = {0x68, 0x69, 0x70, 0x71};
// bool dataOk = false;
// bool dataOk2 = false;
// auto chanlReqCalBack = [&successfullyReceive]
// (const std::shared_ptr<dht::crypto::Certificate>&, const std::string&)
// {
// successfullyReceive = true;
// return true;
// };
// bobConMngr.onChannelRequest(chanlReqCalBack);
// auto conctReadyCalBack =[&]
// (const DeviceId&, const std::string& name, std::shared_ptr<ChannelSocket> socket)
// {
// if (socket && (name == "test" || name == "other")) {
// receiverConnected = true;
// std::error_code ec;
// auto res = socket->waitForData(std::chrono::milliseconds(5000), ec);
// if (res == 4) {
// uint8_t buf[4];
// socket->read(&buf[0], 4, ec);
// if (name == "test")
// dataOk = std::equal(std::begin(buf), std::end(buf), std::begin(buf_test));
// else
// dataOk2 = std::equal(std::begin(buf), std::end(buf), std::begin(buf_other));
// events++;
// cv.notify_one();
// }
// }
// };
// bobConMngr.onConnectionReady(conctReadyCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket) {
// successfullyConnected = true;
// std::error_code ec;
// socket->write(&buf_test[0], 4, ec);
// }
// events++;
// cv.notify_one();
// };
// alicConMngr.connectDevice(bobDevicId, "test", conctDevicCalBack);
// auto conctDevicCalBack2 = [&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket) {
// successfullyConnected2 = true;
// std::error_code ec;
// socket->write(&buf_other[0], 4, ec);
// }
// events++;
// cv.notify_one();
// };
// alicConMngr.connectDevice(bobDevicId, "other", conctDevicCalBack2);
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return events == 4 && successfullyReceive && successfullyConnected && successfullyConnected2
// && dataOk && dataOk2;
// }));
// }
// /* void
// ConnectionManagerTest::testAcceptsICERequest()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// bobAccount->connectionManager().onChannelRequest(
// [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onICERequest([&](const DeviceId&) {
// successfullyReceive = true;
// return true;
// });
// bobAccount->connectionManager().onConnectionReady(
// [&receiverConnected](const DeviceId&,
// const std::string& name,
// std::shared_ptr<ChannelSocket> socket) {
// receiverConnected = socket && (name == "git://*");
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] {
// return successfullyReceive && successfullyConnected && receiverConnected;
// }));
// } */
// void
// ConnectionManagerTest::testAcceptsICERequest()
// {
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// bobAccount->connectionManager().onChannelRequest(
// [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onICERequest([&](const DeviceId&) {
// successfullyReceive = true;
// return true;
// });
// bobAccount->connectionManager().onConnectionReady(
// [&receiverConnected](const DeviceId&,
// const std::string& name,
// std::shared_ptr<ChannelSocket> socket) {
// receiverConnected = socket && (name == "git://*");
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] {
// return successfullyReceive && successfullyConnected && receiverConnected;
// }));
// }
// /* void
// ConnectionManagerTest::testDeclineICERequest()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// bobAccount->connectionManager().onChannelRequest(
// [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onICERequest([&](const DeviceId&) {
// successfullyReceive = true;
// return false;
// });
// bobAccount->connectionManager().onConnectionReady(
// [&receiverConnected](const DeviceId&,
// const std::string& name,
// std::shared_ptr<ChannelSocket> socket) {
// receiverConnected = socket && (name == "git://*");
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// cv.wait_for(lk, 30s);
// CPPUNIT_ASSERT(successfullyReceive);
// CPPUNIT_ASSERT(!receiverConnected);
// CPPUNIT_ASSERT(!successfullyConnected);
// } */
// //why you invoke other functions when you want to test ICErequest?
// void
// ConnectionManagerTest::testDeclineICERequest()
// {
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// bobAccount->connectionManager().onChannelRequest(
// [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onICERequest([&](const DeviceId&) {
// successfullyReceive = true;
// return false; //???????????????????????? is this the point?
// });
// bobAccount->connectionManager().onConnectionReady(
// [&receiverConnected](const DeviceId&,
// const std::string& name,
// std::shared_ptr<ChannelSocket> socket) {
// receiverConnected = socket && (name == "git://*");
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// cv.wait_for(lk, 30s);
// CPPUNIT_ASSERT(successfullyReceive);
// CPPUNIT_ASSERT(!receiverConnected);
// CPPUNIT_ASSERT(!successfullyConnected);
// }
// //I think you testing something other than the current class!
// /*
// void
// ConnectionManagerTest::testChannelRcvShutdown()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool shutdownReceived = false;
// std::shared_ptr<ChannelSocket> bobSock;
// bobAccount->connectionManager().onChannelRequest(
// [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId& did, const std::string& name, std::shared_ptr<ChannelSocket> socket) {
// if (socket && name == "git://*" && did != bobDeviceId) {
// bobSock = socket;
// cv.notify_one();
// }
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// socket->onShutdown([&] {
// shutdownReceived = true;
// cv.notify_one();
// });
// successfullyConnected = true;
// cv.notify_one();
// }
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return bobSock && successfullyConnected; }));
// bobSock->shutdown();
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return shutdownReceived; }));
// }
// */
// void
// ConnectionManagerTest::testChannelRcvShutdown()
// {
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool shutdownReceived = false;
// std::shared_ptr<ChannelSocket> bobSock;
// bobAccount->connectionManager().onChannelRequest(
// [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId& did, const std::string& name, std::shared_ptr<ChannelSocket> socket) {
// if (socket && name == "git://*" && did != bobDeviceId) {
// bobSock = socket;
// cv.notify_one();
// }
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// socket->onShutdown([&] {
// shutdownReceived = true;
// cv.notify_one();
// });
// successfullyConnected = true;
// cv.notify_one();
// }
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return bobSock && successfullyConnected; }));
// bobSock->shutdown();
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return shutdownReceived; }));
// }
// //I think you testing something other than the current class!
// void
// ConnectionManagerTest::testChannelSenderShutdown()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable rcv, scv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// bool shutdownReceived = false;
// bobAccount->connectionManager().onChannelRequest(
// [&successfullyReceive](const std::shared_ptr<dht::crypto::Certificate>&,
// const std::string& name) {
// successfullyReceive = name == "git://*";
// return true;
// });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId&, const std::string& name, std::shared_ptr<ChannelSocket> socket) {
// if (socket) {
// socket->onShutdown([&] {
// shutdownReceived = true;
// scv.notify_one();
// });
// }
// receiverConnected = socket && (name == "git://*");
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// rcv.notify_one();
// socket->shutdown();
// }
// });
// rcv.wait_for(lk, 30s);
// scv.wait_for(lk, 30s);
// CPPUNIT_ASSERT(shutdownReceived);
// CPPUNIT_ASSERT(successfullyReceive);
// CPPUNIT_ASSERT(successfullyConnected);
// CPPUNIT_ASSERT(receiverConnected);
// }
// //how to get URI?
// //The call back function has different logic. Also, there are cuncurrenct tasks here. Please explain them.
// void
// ConnectionManagerTest::testCloseConnectionWith()
// {
// auto bobUri = bobAccount->getUsername();
// std::condition_variable rcv, scv;
// std::atomic_int events(0);
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// auto chanlReqCalBack = [&successfullyReceive]
// (const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name)
// {
// successfullyReceive = name == "git://*";
// return true;
// };
// bobConMngr.onChannelRequest(chanlReqCalBack);
// auto conctReadyCalBack =[&]
// (const DeviceId&, const std::string& name, std::shared_ptr<ChannelSocket> socket)
// {
// if (socket) {
// socket->onShutdown([&] {
// events += 1;// this is an atomic variable why not using atomic operation i.e event.fetch_add(1)
// scv.notify_one();
// });
// }
// receiverConnected = socket && (name == "git://*");
// }
// bobConMngr.onConnectionReady(conctReadyCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket,const DeviceId&)
// {
// if (socket) {
// socket->onShutdown([&] {
// events += 1;
// scv.notify_one();
// });
// successfullyConnected = true;
// rcv.notify_one();
// }
// };
// alicConMngr.connectDevice(bobDevicId, "git://*", conctDevicCalBack);
// CPPUNIT_ASSERT(rcv.wait_for(lk, 60s, [&] {
// return successfullyReceive && successfullyConnected && receiverConnected;
// }));
// // This should trigger onShutdown
// alicConMngr.closeConnectionsWith(bobUri);
// CPPUNIT_ASSERT(scv.wait_for(lk, 60s, [&] {
// return events == 2;
// }));
// }
// //explain algorithm
// void
// ConnectionManagerTest::testShutdownCallbacks()
// {
// auto aliceUri = aliceAccount->getUsername();
// std::condition_variable rcv, chan2cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// auto chanlReqCalBack = [&successfullyReceive, &chan2cv]
// (const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name)
// {
// if (name == "1") {
// successfullyReceive = true;
// } else {
// chan2cv.notify_one();
// // Do not return directly. Let the connection be closed
// std::this_thread::sleep_for(10s);
// }
// return true;
// };
// bobConMngr.onChannelRequest(chanlReqCalBack);
// auto conctReadyCalBack =[&]
// (const DeviceId&, const std::string& name, std::shared_ptr<ChannelSocket> socket)
// {
// receiverConnected = socket && (name == "1");
// };
// bobConMngr.onConnectionReady(conctReadyCalBack);
// auto conctDevicCalBack =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// if (socket) {
// successfullyConnected = true;
// rcv.notify_one();
// }
// };
// alicConMngr.connectDevice(bobDeviceId, "1", conctDevicCalBack);
// // Connect first channel. This will initiate a mx sock ?????????????????????????????????????????????????????
// CPPUNIT_ASSERT(rcv.wait_for(lk, 30s, [&] {
// return successfullyReceive && successfullyConnected && receiverConnected;
// }));
// // Connect another channel, but close the connection
// bool channel2NotConnected = false;
// auto conctDevicCalBack2 =[&]
// (std::shared_ptr<ChannelSocket> socket, const DeviceId&)
// {
// channel2NotConnected = !socket;
// rcv.notify_one();
// };
// alicConMngr.connectDevice(bobDeviceId, "2", conctDevicCalBack2);
// chan2cv.wait_for(lk, 30s);
// // This should trigger onShutdown for second callback
// bobConMngr.closeConnectionsWith(aliceUri);
// CPPUNIT_ASSERT(rcv.wait_for(lk, 30s, [&] { return channel2NotConnected; }));
// }
// //What is the story?
// void
// ConnectionManagerTest::testFloodSocket()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// std::shared_ptr<ChannelSocket> rcvSock1, rcvSock2, rcvSock3, sendSock, sendSock2, sendSock3;
// bobAccount->connectionManager().onChannelRequest(
// [&successfullyReceive](const std::shared_ptr<dht::crypto::Certificate>&,
// const std::string& name) {
// successfullyReceive = name == "1";
// return true;
// });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId&, const std::string& name, std::shared_ptr<ChannelSocket> socket) {
// receiverConnected = socket != nullptr;
// if (name == "1")
// rcvSock1 = socket;
// else if (name == "2")
// rcvSock2 = socket;
// else if (name == "3")
// rcvSock3 = socket;
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "1",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// sendSock = socket;
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] {
// return successfullyReceive && successfullyConnected && receiverConnected;
// }));
// CPPUNIT_ASSERT(receiverConnected);
// successfullyConnected = false;
// receiverConnected = false;
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "2",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// sendSock2 = socket;
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return successfullyConnected && receiverConnected; }));
// successfullyConnected = false;
// receiverConnected = false;
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "3",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// sendSock3 = socket;
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return successfullyConnected && receiverConnected; }));
// std::mutex mtxRcv {};
// std::string alphabet, shouldRcv, rcv1, rcv2, rcv3;
// for (int i = 0; i < 100; ++i)
// alphabet += "QWERTYUIOPASDFGHJKLZXCVBNM";
// // Qx8000
// // Wx8000
// // Ex8000
// // ...
// // Qx8000
// // Wx8000
// // Ex8000
// // ... x 99
// rcvSock1->setOnRecv([&](const uint8_t* buf, size_t len) {
// rcv1 += std::string(buf, buf + len);
// return len;
// });
// rcvSock2->setOnRecv([&](const uint8_t* buf, size_t len) {
// rcv2 += std::string(buf, buf + len);
// return len;
// });
// rcvSock3->setOnRecv([&](const uint8_t* buf, size_t len) {
// rcv3 += std::string(buf, buf + len);
// return len;
// });
// for (uint64_t i = 0; i < alphabet.size(); ++i) {
// auto send = std::string(8000, alphabet[i]);
// shouldRcv += send;
// std::error_code ec;
// sendSock->write(reinterpret_cast<unsigned char*>(send.data()), send.size(), ec);
// sendSock2->write(reinterpret_cast<unsigned char*>(send.data()), send.size(), ec);
// sendSock3->write(reinterpret_cast<unsigned char*>(send.data()), send.size(), ec);
// CPPUNIT_ASSERT(!ec);
// }
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
// return shouldRcv == rcv1 && shouldRcv == rcv2 && shouldRcv == rcv3;
// }));
// }
// void
// ConnectionManagerTest::testDestroyWhileSending()
// {
// // Same as test before, but destroy the accounts while sending.
// // This test if a segfault occurs
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bool receiverConnected = false;
// std::shared_ptr<ChannelSocket> rcvSock1, rcvSock2, rcvSock3, sendSock, sendSock2, sendSock3;
// bobAccount->connectionManager().onChannelRequest(
// [&successfullyReceive](const std::shared_ptr<dht::crypto::Certificate>&,
// const std::string& name) {
// successfullyReceive = name == "1";
// return true;
// });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId&, const std::string& name, std::shared_ptr<ChannelSocket> socket) {
// receiverConnected = socket != nullptr;
// if (name == "1")
// rcvSock1 = socket;
// else if (name == "2")
// rcvSock2 = socket;
// else if (name == "3")
// rcvSock3 = socket;
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "1",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// sendSock = socket;
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] {
// return successfullyReceive && successfullyConnected && receiverConnected;
// }));
// successfullyConnected = false;
// receiverConnected = false;
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "2",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// sendSock2 = socket;
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return successfullyConnected && receiverConnected; }));
// successfullyConnected = false;
// receiverConnected = false;
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "3",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// sendSock3 = socket;
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return successfullyConnected && receiverConnected; }));
// std::mutex mtxRcv {};
// std::string alphabet;
// for (int i = 0; i < 100; ++i)
// alphabet += "QWERTYUIOPASDFGHJKLZXCVBNM";
// rcvSock1->setOnRecv([&](const uint8_t*, size_t len) { return len; });
// rcvSock2->setOnRecv([&](const uint8_t*, size_t len) { return len; });
// rcvSock3->setOnRecv([&](const uint8_t*, size_t len) { return len; });
// for (uint64_t i = 0; i < alphabet.size(); ++i) {
// auto send = std::string(8000, alphabet[i]);
// std::error_code ec;
// sendSock->write(reinterpret_cast<unsigned char*>(send.data()), send.size(), ec);
// sendSock2->write(reinterpret_cast<unsigned char*>(send.data()), send.size(), ec);
// sendSock3->write(reinterpret_cast<unsigned char*>(send.data()), send.size(), ec);
// CPPUNIT_ASSERT(!ec);
// }
// // No need to wait, immediately destroy, no segfault must occurs
// }
// //why you don't use this function in other test units to validate a test?
// /*
// void
// ConnectionManagerTest::testIsConnecting()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false, successfullyReceive = false;
// bobAccount->connectionManager().onChannelRequest(
// [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) {
// successfullyReceive = true;
// cv.notify_one();
// std::this_thread::sleep_for(2s);
// return true;
// });
// CPPUNIT_ASSERT(!aliceAccount->connectionManager().isConnecting(bobDeviceId, "sip"));
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "sip",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// // connectDevice is full async, so isConnecting will be true after a few ms.
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return successfullyReceive; }));
// CPPUNIT_ASSERT(aliceAccount->connectionManager().isConnecting(bobDeviceId, "sip"));
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return successfullyConnected; }));
// std::this_thread::sleep_for(
// std::chrono::milliseconds(100)); // Just to wait for the callback to finish
// CPPUNIT_ASSERT(!aliceAccount->connectionManager().isConnecting(bobDeviceId, "sip"));
// }
// */
// void
// ConnectionManagerTest::testIsConnecting()
// {
// std::condition_variable cv;
// bool successfullyConnected = false;
// bool successfullyReceive = false;
// bobAccount->connectionManager().onChannelRequest(
// [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) {
// successfullyReceive = true;
// cv.notify_one();
// std::this_thread::sleep_for(2s);
// return true;
// });
// CPPUNIT_ASSERT(!aliceAccount->connectionManager().isConnecting(bobDeviceId, "sip"));
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "sip",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// // connectDevice is full async, so isConnecting will be true after a few ms.
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return successfullyReceive; }));
// CPPUNIT_ASSERT(aliceAccount->connectionManager().isConnecting(bobDeviceId, "sip"));
// CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return successfullyConnected; }));
// std::this_thread::sleep_for(
// std::chrono::milliseconds(100)); // Just to wait for the callback to finish
// CPPUNIT_ASSERT(!aliceAccount->connectionManager().isConnecting(bobDeviceId, "sip"));
// }
// void
// ConnectionManagerTest::testCanSendBeacon()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// std::shared_ptr<MultiplexedSocket> aliceSocket, bobSocket;
// bobAccount->connectionManager().onChannelRequest(
// [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId&, const std::string&, std::shared_ptr<ChannelSocket> socket) {
// if (socket && socket->name() == "sip")
// bobSocket = socket->underlyingSocket();
// cv.notify_one();
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "sip",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// aliceSocket = socket->underlyingSocket();
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// // connectDevice is full async, so isConnecting will be true after a few ms.
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return aliceSocket && bobSocket && successfullyConnected; }));
// CPPUNIT_ASSERT(aliceSocket->canSendBeacon());
// // Because onConnectionReady is true before version is sent, we can wait a bit
// // before canSendBeacon is true.
// auto start = std::chrono::steady_clock::now();
// auto aliceCanSendBeacon = false;
// auto bobCanSendBeacon = false;
// do {
// aliceCanSendBeacon = aliceSocket->canSendBeacon();
// bobCanSendBeacon = bobSocket->canSendBeacon();
// if (!bobCanSendBeacon || !aliceCanSendBeacon)
// std::this_thread::sleep_for(1s);
// } while ((not bobCanSendBeacon or not aliceCanSendBeacon)
// and std::chrono::steady_clock::now() - start < 5s);
// CPPUNIT_ASSERT(bobCanSendBeacon && aliceCanSendBeacon);
// }
// void
// ConnectionManagerTest::testCannotSendBeacon()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// std::shared_ptr<MultiplexedSocket> aliceSocket, bobSocket;
// bobAccount->connectionManager().onChannelRequest(
// [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId&, const std::string&, std::shared_ptr<ChannelSocket> socket) {
// if (socket && socket->name() == "sip")
// bobSocket = socket->underlyingSocket();
// cv.notify_one();
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "sip",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// aliceSocket = socket->underlyingSocket();
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// // connectDevice is full async, so isConnecting will be true after a few ms.
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return aliceSocket && bobSocket; }));
// int version = 1412;
// bobSocket->setOnVersionCb([&](auto v) {
// version = v;
// cv.notify_one();
// });
// aliceSocket->setVersion(0);
// aliceSocket->sendVersion();
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return version == 0; }));
// CPPUNIT_ASSERT(!bobSocket->canSendBeacon());
// }
// void
// ConnectionManagerTest::testConnectivityChangeTriggerBeacon()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// std::shared_ptr<MultiplexedSocket> aliceSocket, bobSocket;
// bobAccount->connectionManager().onChannelRequest(
// [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId&, const std::string&, std::shared_ptr<ChannelSocket> socket) {
// if (socket && socket->name() == "sip")
// bobSocket = socket->underlyingSocket();
// cv.notify_one();
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "sip",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// aliceSocket = socket->underlyingSocket();
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// // connectDevice is full async, so isConnecting will be true after a few ms.
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return aliceSocket && bobSocket; }));
// bool hasRequest = false;
// bobSocket->setOnBeaconCb([&](auto p) {
// if (p)
// hasRequest = true;
// cv.notify_one();
// });
// aliceAccount->connectionManager().connectivityChanged();
// CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return hasRequest; }));
// }
// void
// ConnectionManagerTest::testOnNoBeaconTriggersShutdown()
// {
// auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
// auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
// auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
// bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// std::mutex mtx;
// std::unique_lock<std::mutex> lk {mtx};
// std::condition_variable cv;
// bool successfullyConnected = false;
// std::shared_ptr<MultiplexedSocket> aliceSocket, bobSocket;
// bobAccount->connectionManager().onChannelRequest(
// [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
// bobAccount->connectionManager().onConnectionReady(
// [&](const DeviceId&, const std::string&, std::shared_ptr<ChannelSocket> socket) {
// if (socket && socket->name() == "sip")
// bobSocket = socket->underlyingSocket();
// cv.notify_one();
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "sip",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// if (socket) {
// aliceSocket = socket->underlyingSocket();
// successfullyConnected = true;
// }
// cv.notify_one();
// });
// // connectDevice is full async, so isConnecting will be true after a few ms.
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return aliceSocket && bobSocket; }));
// bool isClosed = false;
// aliceSocket->onShutdown([&] {
// isClosed = true;
// cv.notify_one();
// });
// bobSocket->answerToBeacon(false);
// aliceAccount->connectionManager().connectivityChanged();
// CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return isClosed; }));*/
// }
// //why you didn't invoke on Channel request?
// void
// ConnectionManagerTest::testShutdownWhileNegotiating()
// {
// std::condition_variable cv;
// bool successfullyReceive = false;
// bool notConnected = false;
// aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
// //Why???????????
// bobAccount->connectionManager().onICERequest([&](const DeviceId&) {
// successfullyReceive = true;
// cv.notify_one();
// return true;
// });
// aliceAccount->connectionManager().connectDevice(bobDeviceId,
// "git://*",
// [&](std::shared_ptr<ChannelSocket> socket,
// const DeviceId&) {
// notConnected = !socket;
// cv.notify_one();
// });
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return successfullyReceive; }));
// aliceAccount->connectionManager().reset(); //use it but check it first
// Manager::instance().setAccountActive(aliceId, false, true);//?????????????????????????????????????
// CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return notConnected; }));
// }
} // namespace test
} // namespace dhtnet
JAMI_TEST_RUNNER(dhtnet::test::ConnectionManagerTest::name())