diff --git a/tests/connectionManager.cpp b/tests/connectionManager.cpp
index ab4274484c3d584b643b0e237a585cf8890e2fc0..ef843ef56b526fd195a5aa99f95098b8ea36e67e 100644
--- a/tests/connectionManager.cpp
+++ b/tests/connectionManager.cpp
@@ -14,21 +14,40 @@
* 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:
@@ -38,408 +57,174 @@ public:
void setUp();
void tearDown();
- std::string aliceId;
- std::string bobId;
+ std::unique_ptr<ConnectionHandler> alice;
+ std::unique_ptr<ConnectionHandler> bob;
+ //std::string aliceId;
+ //std::string bobId;
+//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:
- 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(testConnectDevice);
- CPPUNIT_TEST(testAcceptConnection);
- CPPUNIT_TEST(testMultipleChannels);
- CPPUNIT_TEST(testMultipleChannelsOneDeclined);
- CPPUNIT_TEST(testMultipleChannelsSameName);
- CPPUNIT_TEST(testDeclineConnection);
- CPPUNIT_TEST(testSendReceiveData);
- CPPUNIT_TEST(testAcceptsICERequest);
- CPPUNIT_TEST(testDeclineICERequest);
- CPPUNIT_TEST(testChannelRcvShutdown);
- CPPUNIT_TEST(testChannelSenderShutdown);
- CPPUNIT_TEST(testCloseConnectionWith);
- CPPUNIT_TEST(testShutdownCallbacks);
- CPPUNIT_TEST(testFloodSocket);
- CPPUNIT_TEST(testDestroyWhileSending);
- CPPUNIT_TEST(testIsConnecting);
- 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());
-
-void
-ConnectionManagerTest::setUp()
-{
- /*auto actors = load_actors_and_wait_for_announcement("actors/alice-bob.yml");
- aliceId = actors["alice"];
- bobId = actors["bob"];
- // Pin certificate from one to another certstore (because we do not perform any DHT operation in this test)
- auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
- auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
- bobAccount->certStore().pinCertificate(aliceAccount->identity().second);
- aliceAccount->certStore().pinCertificate(bobAccount->identity().second);*/
-}
+ 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();
-void
-ConnectionManagerTest::tearDown()
-{
- //wait_for_removal_of({aliceId, bobId});
-}
+ CPPUNIT_TEST_SUITE(ConnectionManagerTest);
-void
-ConnectionManagerTest::testConnectDevice()
-{
- /*auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
- auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
- auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
+ // CPPUNIT_TEST(testAcceptsICERequest);
+ // CPPUNIT_TEST(testDeclineICERequest);
- bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
- aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
+ CPPUNIT_TEST(testConnectDevice);
- std::mutex mtx;
- std::unique_lock<std::mutex> lk {mtx};
- std::condition_variable cv, cvReceive;
- bool successfullyConnected = false;
- bool successfullyReceive = false;
+ // CPPUNIT_TEST(testIsConnecting);
- bobAccount->connectionManager().onChannelRequest(
- [&successfullyReceive, &cvReceive](const std::shared_ptr<dht::crypto::Certificate>&,
- const std::string& name) {
- successfullyReceive = name == "git://*";
- cvReceive.notify_one();
- return true;
- });
+ // CPPUNIT_TEST(testAcceptConnection);
+ // CPPUNIT_TEST(testDeclineConnection);
- 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; }));*/
-}
+ // CPPUNIT_TEST(testMultipleChannels);
+ // CPPUNIT_TEST(testMultipleChannelsOneDeclined);
+ // CPPUNIT_TEST(testMultipleChannelsSameName);
+
+ // CPPUNIT_TEST(testSendReceiveData);
-void
-ConnectionManagerTest::testAcceptConnection()
-{
- /*auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
- auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
- auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
+ // CPPUNIT_TEST(testChannelRcvShutdown);
+ // CPPUNIT_TEST(testChannelSenderShutdown);
- bobAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
- aliceAccount->connectionManager().onICERequest([](const DeviceId&) { return true; });
+ // CPPUNIT_TEST(testCloseConnectionWith);
+ // CPPUNIT_TEST(testShutdownCallbacks);
+ // CPPUNIT_TEST(testFloodSocket);
+ // CPPUNIT_TEST(testDestroyWhileSending);
- std::mutex mtx;
- std::unique_lock<std::mutex> lk {mtx};
- std::condition_variable cv;
- bool successfullyConnected = false;
- bool successfullyReceive = false;
- bool receiverConnected = false;
+ // CPPUNIT_TEST(testCanSendBeacon);
+ // CPPUNIT_TEST(testCannotSendBeacon);
+ // CPPUNIT_TEST(testConnectivityChangeTriggerBeacon);
+ // CPPUNIT_TEST(testOnNoBeaconTriggersShutdown);
+ // CPPUNIT_TEST(testShutdownWhileNegotiating);
+ CPPUNIT_TEST_SUITE_END();
+};
- bobAccount->connectionManager().onChannelRequest(
- [&successfullyReceive](const std::shared_ptr<dht::crypto::Certificate>&,
- const std::string& name) {
- successfullyReceive = name == "git://*";
- return true;
- });
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(ConnectionManagerTest, ConnectionManagerTest::name());
- bobAccount->connectionManager().onConnectionReady(
- [&receiverConnected](const DeviceId&,
- const std::string& name,
- std::shared_ptr<ChannelSocket> socket) {
- receiverConnected = socket && (name == "git://*");
- });
+std::unique_ptr<ConnectionHandler>
+ConnectionManagerTest::setupHandler(const std::string& name) {
+ auto h = std::make_unique<ConnectionHandler>();
+ h->id = dht::crypto::generateIdentity(name);
+ 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;
+ }
+ });
- aliceAccount->connectionManager().connectDevice(bobDeviceId,
- "git://*",
- [&](std::shared_ptr<ChannelSocket> socket,
- const DeviceId&) {
- if (socket) {
- successfullyConnected = true;
- }
- cv.notify_one();
- });
+ 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;
+ });
- CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
- return successfullyReceive && successfullyConnected && receiverConnected;
- }));*/
+ return h;
}
void
-ConnectionManagerTest::testMultipleChannels()
+ConnectionManagerTest::setUp()
{
- /*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);*/
+ logger = dht::log::getStdLogger();
+ 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>();
+ alice = setupHandler("alice");
+ bob = setupHandler("bob");
}
-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();
- });
+/*
+ auto identifier = bobId.first->getPublicKey().getLongId();
+ auto identifier = bobId.second->getLongId();
+ auto identifier = bobId.second->getPublicKey().getLongId();
+*/
- CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
- return successfullyNotConnected && successfullyConnected2 && receiverConnected == 1;
- }));
- CPPUNIT_ASSERT(aliceAccount->connectionManager().activeSockets() == 1);*/
-}
void
-ConnectionManagerTest::testMultipleChannelsSameName()
+ConnectionManagerTest::tearDown()
{
- /*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();
- });
-
- // 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;
- }));*/
+ //wait_for_removal_of({aliceId, bobId}); //?????????????????????????????????
+ ioContext->stop();
+ if (ioContextRunner.joinable())
+ ioContextRunner.join();
}
+/*
void
-ConnectionManagerTest::testSendReceiveData()
+ConnectionManagerTest::testConnectDevice()
{
- /*auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
+ 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::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; });
@@ -447,24 +232,16 @@ ConnectionManagerTest::testDeclineConnection()
std::mutex mtx;
std::unique_lock<std::mutex> lk {mtx};
- std::condition_variable cv;
+ std::condition_variable cv, cvReceive;
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;
+ [&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,
@@ -476,798 +253,1733 @@ ConnectionManagerTest::testDeclineConnection()
}
cv.notify_one();
});
- cv.wait_for(lk, 30s);
- CPPUNIT_ASSERT(successfullyReceive);
- CPPUNIT_ASSERT(!successfullyConnected);
- CPPUNIT_ASSERT(!receiverConnected);*/
+
+ CPPUNIT_ASSERT(cvReceive.wait_for(lk, 60s, [&] { return successfullyReceive; }));
+ CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] { return successfullyConnected; }));
+
+
}
+*/
void
-ConnectionManagerTest::testAcceptsICERequest()
+ConnectionManagerTest::testConnectDevice()
{
- /*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;
- });
+ 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; }));
+}
- 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);*/
-}
-
-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::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);*/
-}
-
-void
-ConnectionManagerTest::testCloseConnectionWith()
-{
- /*auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
- auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
- auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
- auto bobUri = bobAccount->getUsername();
-
- 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;
- std::atomic_int events(0);
- 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(
- [&](const DeviceId&, const std::string& name, std::shared_ptr<ChannelSocket> socket) {
- if (socket) {
- socket->onShutdown([&] {
- events += 1;
- scv.notify_one();
- });
- }
- receiverConnected = socket && (name == "git://*");
- });
-
- aliceAccount->connectionManager().connectDevice(bobDeviceId,
- "git://*",
- [&](std::shared_ptr<ChannelSocket> socket,
- const DeviceId&) {
- if (socket) {
- socket->onShutdown([&] {
- events += 1;
- scv.notify_one();
- });
- successfullyConnected = true;
- rcv.notify_one();
- }
- });
-
- rcv.wait_for(lk, 30s);
- // This should trigger onShutdown
- aliceAccount->connectionManager().closeConnectionsWith(bobUri);
- CPPUNIT_ASSERT(scv.wait_for(lk, 60s, [&] {
- return events == 2 && successfullyReceive && successfullyConnected && receiverConnected;
- }));*/
-}
-
-void
-ConnectionManagerTest::testShutdownCallbacks()
-{
- /*auto aliceAccount = Manager::instance().getAccount<JamiAccount>(aliceId);
- auto bobAccount = Manager::instance().getAccount<JamiAccount>(bobId);
- auto bobDeviceId = DeviceId(std::string(bobAccount->currentDeviceId()));
- auto aliceUri = aliceAccount->getUsername();
-
- 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, chan2cv;
- bool successfullyConnected = false;
- bool successfullyReceive = false;
- bool receiverConnected = false;
-
- bobAccount->connectionManager().onChannelRequest(
- [&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;
- });
-
- bobAccount->connectionManager().onConnectionReady(
- [&](const DeviceId&, const std::string& name, std::shared_ptr<ChannelSocket> socket) {
- receiverConnected = socket && (name == "1");
- });
-
- aliceAccount->connectionManager().connectDevice(bobDeviceId,
- "1",
- [&](std::shared_ptr<ChannelSocket> socket,
- const DeviceId&) {
- if (socket) {
- successfullyConnected = true;
- rcv.notify_one();
- }
- });
- // 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;
- aliceAccount->connectionManager().connectDevice(bobDeviceId,
- "2",
- [&](std::shared_ptr<ChannelSocket> socket,
- const DeviceId&) {
- channel2NotConnected = !socket;
- rcv.notify_one();
- });
- chan2cv.wait_for(lk, 30s);
-
- // This should trigger onShutdown for second callback
- bobAccount->connectionManager().closeConnectionsWith(aliceUri);
- CPPUNIT_ASSERT(rcv.wait_for(lk, 30s, [&] { return channel2NotConnected; }));*/
-}
-
-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";
- 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
-}
-
-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::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; }));*/
-}
-
-void
-ConnectionManagerTest::testShutdownWhileNegotiating()
-{
- /*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 successfullyReceive = false;
- bool notConnected = false;
-
- 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; }));
- Manager::instance().setAccountActive(aliceId, false, true);
- CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return notConnected; }));*/
-}
+// /*
+// 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