jens/flipper
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Apply clang-format

Browse Source 
Differential Revision: D19843069

fbshipit-source-id: af3f3998e2259ca5070b43ffb19933cf9304319d
This commit is contained in:
Andres Suarez
2020-02-11 19:27:40 -08:00
committed by Facebook Github Bot
parent 71928fdf08
commit c315691b2d
10 changed files with 195 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

188
android/src/main/cpp/sonar.cpp
View File

@@ -13,16 +13,16 @@
#include <fb/fbjni.h> #include <fb/fbjni.h>
#endif #endif
#include <folly/json.h>
#include <folly/io/async/EventBase.h> #include <folly/io/async/EventBase.h>
#include <folly/io/async/EventBaseManager.h> #include <folly/io/async/EventBaseManager.h>
#include <folly/json.h>
#include <Flipper/FlipperClient.h> #include <Flipper/FlipperClient.h>
#include <Flipper/FlipperConnectionManager.h>
#include <Flipper/FlipperConnection.h> #include <Flipper/FlipperConnection.h>
#include <Flipper/FlipperConnectionManager.h>
#include <Flipper/FlipperResponder.h> #include <Flipper/FlipperResponder.h>
#include <Flipper/FlipperStateUpdateListener.h>
#include <Flipper/FlipperState.h> #include <Flipper/FlipperState.h>
#include <Flipper/FlipperStateUpdateListener.h>
using namespace facebook; using namespace facebook;
using namespace facebook::flipper; using namespace facebook::flipper;
@@ -37,7 +37,8 @@ void handleException(const std::exception& e) {
class JEventBase : public jni::HybridClass<JEventBase> { class JEventBase : public jni::HybridClass<JEventBase> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/android/EventBase;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/android/EventBase;";
static void registerNatives() { static void registerNatives() {
registerHybrid({ registerHybrid({
@@ -69,86 +70,113 @@ class JEventBase : public jni::HybridClass<JEventBase> {
class JFlipperObject : public jni::JavaClass<JFlipperObject> { class JFlipperObject : public jni::JavaClass<JFlipperObject> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/core/FlipperObject;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/core/FlipperObject;";
static jni::local_ref<JFlipperObject> create(const folly::dynamic& json) { static jni::local_ref<JFlipperObject> create(const folly::dynamic& json) {
return newInstance(folly::toJson(json)); return newInstance(folly::toJson(json));
} }
std::string toJsonString() { std::string toJsonString() {
static const auto method = javaClassStatic()->getMethod<std::string()>("toJsonString"); static const auto method =
javaClassStatic()->getMethod<std::string()>("toJsonString");
return method(self())->toStdString(); return method(self())->toStdString();
} }
}; };
class JFlipperArray : public jni::JavaClass<JFlipperArray> { class JFlipperArray : public jni::JavaClass<JFlipperArray> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/core/FlipperArray;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/core/FlipperArray;";
static jni::local_ref<JFlipperArray> create(const folly::dynamic& json) { static jni::local_ref<JFlipperArray> create(const folly::dynamic& json) {
return newInstance(folly::toJson(json)); return newInstance(folly::toJson(json));
} }
std::string toJsonString() { std::string toJsonString() {
static const auto method = javaClassStatic()->getMethod<std::string()>("toJsonString"); static const auto method =
javaClassStatic()->getMethod<std::string()>("toJsonString");
return method(self())->toStdString(); return method(self())->toStdString();
} }
}; };
class JFlipperResponder : public jni::JavaClass<JFlipperResponder> { class JFlipperResponder : public jni::JavaClass<JFlipperResponder> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/core/FlipperResponder;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/core/FlipperResponder;";
}; };
class JFlipperResponderImpl : public jni::HybridClass<JFlipperResponderImpl, JFlipperResponder> { class JFlipperResponderImpl
: public jni::HybridClass<JFlipperResponderImpl, JFlipperResponder> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/android/FlipperResponderImpl;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/android/FlipperResponderImpl;";
static void registerNatives() { static void registerNatives() {
registerHybrid({ registerHybrid({
makeNativeMethod("successObject", JFlipperResponderImpl::successObject), makeNativeMethod("successObject", JFlipperResponderImpl::successObject),
makeNativeMethod("successArray", JFlipperResponderImpl::successArray), makeNativeMethod("successArray", JFlipperResponderImpl::successArray),
makeNativeMethod("error", JFlipperResponderImpl::error), makeNativeMethod("error", JFlipperResponderImpl::error),
}); });
} }
void successObject(jni::alias_ref<JFlipperObject> json) { void successObject(jni::alias_ref<JFlipperObject> json) {
_responder->success(json ? folly::parseJson(json->toJsonString()) : folly::dynamic::object()); _responder->success(
json ? folly::parseJson(json->toJsonString())
: folly::dynamic::object());
} }
void successArray(jni::alias_ref<JFlipperArray> json) { void successArray(jni::alias_ref<JFlipperArray> json) {
_responder->success(json ? folly::parseJson(json->toJsonString()) : folly::dynamic::object()); _responder->success(
json ? folly::parseJson(json->toJsonString())
: folly::dynamic::object());
} }
void error(jni::alias_ref<JFlipperObject> json) { void error(jni::alias_ref<JFlipperObject> json) {
_responder->error(json ? folly::parseJson(json->toJsonString()) : folly::dynamic::object()); _responder->error(
json ? folly::parseJson(json->toJsonString())
: folly::dynamic::object());
} }
private: private:
friend HybridBase; friend HybridBase;
std::shared_ptr<FlipperResponder> _responder; std::shared_ptr<FlipperResponder> _responder;
JFlipperResponderImpl(std::shared_ptr<FlipperResponder> responder): _responder(std::move(responder)) {} JFlipperResponderImpl(std::shared_ptr<FlipperResponder> responder)
: _responder(std::move(responder)) {}
}; };
class JFlipperReceiver : public jni::JavaClass<JFlipperReceiver> { class JFlipperReceiver : public jni::JavaClass<JFlipperReceiver> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/core/FlipperReceiver;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/core/FlipperReceiver;";
void receive(const folly::dynamic params, std::shared_ptr<FlipperResponder> responder) const { void receive(
static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFlipperObject::javaobject>, jni::alias_ref<JFlipperResponder::javaobject>)>("onReceive"); const folly::dynamic params,
method(self(), JFlipperObject::create(std::move(params)), JFlipperResponderImpl::newObjectCxxArgs(responder)); std::shared_ptr<FlipperResponder> responder) const {
static const auto method =
javaClassStatic()
->getMethod<void(
jni::alias_ref<JFlipperObject::javaobject>,
jni::alias_ref<JFlipperResponder::javaobject>)>("onReceive");
method(
self(),
JFlipperObject::create(std::move(params)),
JFlipperResponderImpl::newObjectCxxArgs(responder));
} }
}; };
class JFlipperConnection : public jni::JavaClass<JFlipperConnection> { class JFlipperConnection : public jni::JavaClass<JFlipperConnection> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/core/FlipperConnection;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/core/FlipperConnection;";
}; };
class JFlipperConnectionImpl : public jni::HybridClass<JFlipperConnectionImpl, JFlipperConnection> { class JFlipperConnectionImpl
: public jni::HybridClass<JFlipperConnectionImpl, JFlipperConnection> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/android/FlipperConnectionImpl;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/android/FlipperConnectionImpl;";
static void registerNatives() { static void registerNatives() {
registerHybrid({ registerHybrid({
@@ -162,12 +190,20 @@ class JFlipperConnectionImpl : public jni::HybridClass<JFlipperConnectionImpl, J
}); });
} }
void sendObject(const std::string method, jni::alias_ref<JFlipperObject> json) { void sendObject(
_connection->send(std::move(method), json ? folly::parseJson(json->toJsonString()) : folly::dynamic::object()); const std::string method,
jni::alias_ref<JFlipperObject> json) {
_connection->send(
std::move(method),
json ? folly::parseJson(json->toJsonString())
: folly::dynamic::object());
} }
void sendArray(const std::string method, jni::alias_ref<JFlipperArray> json) { void sendArray(const std::string method, jni::alias_ref<JFlipperArray> json) {
_connection->send(std::move(method), json ? folly::parseJson(json->toJsonString()) : folly::dynamic::object()); _connection->send(
std::move(method),
json ? folly::parseJson(json->toJsonString())
: folly::dynamic::object());
} }
void reportErrorWithMetadata( void reportErrorWithMetadata(
@@ -181,26 +217,35 @@ class JFlipperConnectionImpl : public jni::HybridClass<JFlipperConnectionImpl, J
throwable->toString(), throwable->getStackTrace()->toString()); throwable->toString(), throwable->getStackTrace()->toString());
} }
void receive(const std::string method, jni::alias_ref<JFlipperReceiver> receiver) { void receive(
const std::string method,
jni::alias_ref<JFlipperReceiver> receiver) {
auto global = make_global(receiver); auto global = make_global(receiver);
_connection->receive(std::move(method), [global] (const folly::dynamic& params, std::shared_ptr<FlipperResponder> responder) { _connection->receive(
global->receive(params, responder); std::move(method),
}); [global](
const folly::dynamic& params,
std::shared_ptr<FlipperResponder> responder) {
global->receive(params, responder);
});
} }
private: private:
friend HybridBase; friend HybridBase;
std::shared_ptr<FlipperConnection> _connection; std::shared_ptr<FlipperConnection> _connection;
JFlipperConnectionImpl(std::shared_ptr<FlipperConnection> connection): _connection(std::move(connection)) {} JFlipperConnectionImpl(std::shared_ptr<FlipperConnection> connection)
: _connection(std::move(connection)) {}
}; };
class JFlipperPlugin : public jni::JavaClass<JFlipperPlugin> { class JFlipperPlugin : public jni::JavaClass<JFlipperPlugin> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/core/FlipperPlugin;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/core/FlipperPlugin;";
std::string identifier() const { std::string identifier() const {
static const auto method = javaClassStatic()->getMethod<std::string()>("getId"); static const auto method =
javaClassStatic()->getMethod<std::string()>("getId");
try { try {
return method(self())->toStdString(); return method(self())->toStdString();
@@ -232,7 +277,8 @@ class JFlipperPlugin : public jni::JavaClass<JFlipperPlugin> {
} }
void didDisconnect() { void didDisconnect() {
static const auto method = javaClassStatic()->getMethod<void()>("onDisconnect"); static const auto method =
javaClassStatic()->getMethod<void()>("onDisconnect");
try { try {
method(self()); method(self());
} catch (const std::exception& e) { } catch (const std::exception& e) {
@@ -244,26 +290,28 @@ class JFlipperPlugin : public jni::JavaClass<JFlipperPlugin> {
} }
} }
bool runInBackground() { bool runInBackground() {
static const auto method = static const auto method =
javaClassStatic()->getMethod<jboolean()>("runInBackground"); javaClassStatic()->getMethod<jboolean()>("runInBackground");
try { try {
return method(self()) == JNI_TRUE; return method(self()) == JNI_TRUE;
} catch (const std::exception& e) { } catch (const std::exception& e) {
handleException(e); handleException(e);
return false; return false;
} catch (const std::exception* e) { } catch (const std::exception* e) {
if (e) { if (e) {
handleException(*e); handleException(*e);
}
return false;
} }
return false;
} }
}
}; };
class JFlipperStateUpdateListener : public jni::JavaClass<JFlipperStateUpdateListener> { class JFlipperStateUpdateListener
: public jni::JavaClass<JFlipperStateUpdateListener> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/core/FlipperStateUpdateListener;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/core/FlipperStateUpdateListener;";
void onUpdate() { void onUpdate() {
try { try {
@@ -322,11 +370,12 @@ class JFlipperStateUpdateListener : public jni::JavaClass<JFlipperStateUpdateLis
class AndroidFlipperStateUpdateListener : public FlipperStateUpdateListener { class AndroidFlipperStateUpdateListener : public FlipperStateUpdateListener {
public: public:
AndroidFlipperStateUpdateListener(jni::alias_ref<JFlipperStateUpdateListener> stateListener); AndroidFlipperStateUpdateListener(
jni::alias_ref<JFlipperStateUpdateListener> stateListener);
void onUpdate(); void onUpdate();
private: private:
jni::global_ref<JFlipperStateUpdateListener> jStateListener; jni::global_ref<JFlipperStateUpdateListener> jStateListener;
}; };
class JFlipperPluginWrapper : public FlipperPlugin { class JFlipperPluginWrapper : public FlipperPlugin {
@@ -345,31 +394,35 @@ class JFlipperPluginWrapper : public FlipperPlugin {
jplugin->didDisconnect(); jplugin->didDisconnect();
} }
virtual bool runInBackground() override { virtual bool runInBackground() override {
return jplugin->runInBackground(); return jplugin->runInBackground();
} }
JFlipperPluginWrapper(jni::global_ref<JFlipperPlugin> plugin): jplugin(plugin) {} JFlipperPluginWrapper(jni::global_ref<JFlipperPlugin> plugin)
: jplugin(plugin) {}
}; };
struct JStateSummary : public jni::JavaClass<JStateSummary> { struct JStateSummary : public jni::JavaClass<JStateSummary> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/core/StateSummary;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/core/StateSummary;";
static jni::local_ref<JStateSummary> create() { static jni::local_ref<JStateSummary> create() {
return newInstance(); return newInstance();
} }
void addEntry(std::string name, std::string state) { void addEntry(std::string name, std::string state) {
static const auto method = javaClassStatic()->getMethod<void(std::string, std::string)>("addEntry"); static const auto method =
javaClassStatic()->getMethod<void(std::string, std::string)>(
"addEntry");
return method(self(), name, state); return method(self(), name, state);
} }
}; };
class JFlipperClient : public jni::HybridClass<JFlipperClient> { class JFlipperClient : public jni::HybridClass<JFlipperClient> {
public: public:
constexpr static auto kJavaDescriptor = "Lcom/facebook/flipper/android/FlipperClientImpl;"; constexpr static auto kJavaDescriptor =
"Lcom/facebook/flipper/android/FlipperClientImpl;";
static void registerNatives() { static void registerNatives() {
registerHybrid({ registerHybrid({
@@ -388,7 +441,8 @@ class JFlipperClient : public jni::HybridClass<JFlipperClient> {
}); });
} }
static jni::alias_ref<JFlipperClient::javaobject> getInstance(jni::alias_ref<jclass>) { static jni::alias_ref<JFlipperClient::javaobject> getInstance(
jni::alias_ref<jclass>) {
try { try {
static auto client = make_global(newObjectCxxArgs()); static auto client = make_global(newObjectCxxArgs());
return client; return client;
@@ -448,7 +502,8 @@ class JFlipperClient : public jni::HybridClass<JFlipperClient> {
} }
} }
void subscribeForUpdates(jni::alias_ref<JFlipperStateUpdateListener> stateListener) { void subscribeForUpdates(
jni::alias_ref<JFlipperStateUpdateListener> stateListener) {
try { try {
auto client = FlipperClient::instance(); auto client = FlipperClient::instance();
mStateListener = mStateListener =
@@ -585,7 +640,8 @@ jint JNI_OnLoad(JavaVM* vm, void*) {
}); });
} }
AndroidFlipperStateUpdateListener::AndroidFlipperStateUpdateListener(jni::alias_ref<JFlipperStateUpdateListener> stateListener) { AndroidFlipperStateUpdateListener::AndroidFlipperStateUpdateListener(
jni::alias_ref<JFlipperStateUpdateListener> stateListener) {
jStateListener = jni::make_global(stateListener); jStateListener = jni::make_global(stateListener);
} }

4
xplat/Flipper/CertificateUtils.cpp
View File

@@ -8,10 +8,10 @@
#include "CertificateUtils.h" #include "CertificateUtils.h"
#include <fcntl.h> #include <fcntl.h>
#include <folly/portability/Fcntl.h>
#include <folly/portability/SysStat.h>
#include <openssl/pem.h> #include <openssl/pem.h>
#include <openssl/rsa.h> #include <openssl/rsa.h>
#include <folly/portability/SysStat.h>
#include <folly/portability/Fcntl.h>
#include <cstring> #include <cstring>
void free( void free(

7
xplat/Flipper/ConnectionContextStore.h
View File

@@ -7,9 +7,9 @@
#pragma once #pragma once
#include <string>
#include <folly/io/async/SSLContext.h>
#include <folly/dynamic.h> #include <folly/dynamic.h>
#include <folly/io/async/SSLContext.h>
#include <string>
#include "FlipperInitConfig.h" #include "FlipperInitConfig.h"
using namespace folly; using namespace folly;
@@ -18,8 +18,7 @@ namespace facebook {
namespace flipper { namespace flipper {
class ConnectionContextStore { class ConnectionContextStore {
public:
public:
ConnectionContextStore(DeviceData deviceData); ConnectionContextStore(DeviceData deviceData);
bool hasRequiredFiles(); bool hasRequiredFiles();
std::string getCertificateSigningRequest(); std::string getCertificateSigningRequest();

2
xplat/Flipper/FlipperConnection.h
View File

@@ -7,10 +7,10 @@
#pragma once #pragma once
#include "FlipperResponder.h"
#include <folly/json.h> #include <folly/json.h>
#include <functional> #include <functional>
#include <string> #include <string>
#include "FlipperResponder.h"
namespace facebook { namespace facebook {
namespace flipper { namespace flipper {

4
xplat/Flipper/FlipperConnectionImpl.h
View File

@@ -18,7 +18,9 @@ namespace flipper {
class FlipperConnectionImpl : public FlipperConnection { class FlipperConnectionImpl : public FlipperConnection {
public: public:
FlipperConnectionImpl(FlipperConnectionManager* socket, const std::string& name) FlipperConnectionImpl(
FlipperConnectionManager* socket,
const std::string& name)
: socket_(socket), name_(name) {} : socket_(socket), name_(name) {}
void call( void call(

5
xplat/Flipper/FlipperPlugin.h
View File

@@ -7,8 +7,8 @@
#pragma once #pragma once
#include "FlipperConnection.h"
#include <string> #include <string>
#include "FlipperConnection.h"
namespace facebook { namespace facebook {
namespace flipper { namespace flipper {
@@ -38,7 +38,8 @@ class FlipperPlugin {
virtual void didDisconnect() = 0; virtual void didDisconnect() = 0;
/** /**
Returns true if the plugin is meant to be run in background too, otherwise it returns false. Returns true if the plugin is meant to be run in background too, otherwise it
returns false.
*/ */
virtual bool runInBackground() { virtual bool runInBackground() {
return false; return false;

16
xplat/Flipper/Log.cpp
View File

@@ -14,14 +14,14 @@
namespace facebook { namespace facebook {
namespace flipper { namespace flipper {
void log(const std::string& message) { void log(const std::string& message) {
#ifdef __ANDROID__ #ifdef __ANDROID__
__android_log_print(ANDROID_LOG_INFO, "flipper", "flipper: %s", message.c_str()); __android_log_print(
#else ANDROID_LOG_INFO, "flipper", "flipper: %s", message.c_str());
printf("flipper: %s\n", message.c_str()); #else
#endif printf("flipper: %s\n", message.c_str());
} #endif
}
} // namespace flipper } // namespace flipper
} // namespace facebook } // namespace facebook

2
xplat/Flipper/Log.h
View File

@@ -12,7 +12,7 @@
namespace facebook { namespace facebook {
namespace flipper { namespace flipper {
void log(const std::string& message); void log(const std::string& message);
} // namespace flipper } // namespace flipper
} // namespace facebook } // namespace facebook

43
xplat/FlipperTestLib/ConnectionContextStoreMock.h
View File

@@ -11,25 +11,26 @@ namespace facebook {
namespace flipper { namespace flipper {
namespace test { namespace test {
class ConnectionContextStoreMock : public ConnectionContextStore { class ConnectionContextStoreMock : public ConnectionContextStore {
public: public:
ConnectionContextStoreMock() : ConnectionContextStore(DeviceData()) { ConnectionContextStoreMock() : ConnectionContextStore(DeviceData()) {}
} bool hasRequiredFiles() {
bool hasRequiredFiles() { return true;
return true; }
} std::string createCertificateSigningRequest() {
std::string createCertificateSigningRequest() { return "thisIsACsr";
return "thisIsACsr"; }
} std::shared_ptr<SSLContext> getSSLContext() {
std::shared_ptr<SSLContext> getSSLContext() { return nullptr;
return nullptr; }
} dynamic getConnectionConfig() {
dynamic getConnectionConfig() { return nullptr;
return nullptr; }
} std::string getCertificateDirectoryPath() {
std::string getCertificateDirectoryPath() { return "/something/sonar/";
return "/something/sonar/"; }
} };
};
}}} } // namespace test
} // namespace flipper
} // namespace facebook

68
xplat/FlipperTests/FlipperConnectionManagerImplTerminationTests.cpp
View File

@@ -18,7 +18,7 @@ namespace test {
using folly::EventBase; using folly::EventBase;
class FlipperConnectionManagerImplTerminationTest : public ::testing::Test { class FlipperConnectionManagerImplTerminationTest : public ::testing::Test {
protected: protected:
std::shared_ptr<FlipperState> state; std::shared_ptr<FlipperState> state;
std::shared_ptr<ConnectionContextStore> contextStore; std::shared_ptr<ConnectionContextStore> contextStore;
void SetUp() override { void SetUp() override {
@@ -30,60 +30,52 @@ protected:
} }
}; };
TEST_F(FlipperConnectionManagerImplTerminationTest, testNullEventBaseGetsRejected) { TEST_F(
FlipperConnectionManagerImplTerminationTest,
testNullEventBaseGetsRejected) {
try { try {
auto instance = std::make_shared<FlipperConnectionManagerImpl>(FlipperInitConfig { auto instance = std::make_shared<FlipperConnectionManagerImpl>(
DeviceData {}, FlipperInitConfig{DeviceData{}, nullptr, new EventBase()},
nullptr, state,
new EventBase() contextStore);
},
state,
contextStore
);
FAIL(); FAIL();
} catch (std::invalid_argument& e) { } catch (std::invalid_argument& e) {
// Pass test // Pass test
} }
try { try {
auto instance = std::make_shared<FlipperConnectionManagerImpl>(FlipperInitConfig { auto instance = std::make_shared<FlipperConnectionManagerImpl>(
DeviceData {}, FlipperInitConfig{DeviceData{}, new EventBase(), nullptr},
new EventBase(), state,
nullptr contextStore);
},
state,
contextStore
);
FAIL(); FAIL();
} catch (std::invalid_argument& e) { } catch (std::invalid_argument& e) {
// Pass test // Pass test
} }
} }
TEST_F(FlipperConnectionManagerImplTerminationTest, testNonStartedEventBaseDoesntHang) { TEST_F(
auto config = FlipperInitConfig { FlipperConnectionManagerImplTerminationTest,
DeviceData {}, testNonStartedEventBaseDoesntHang) {
new EventBase(), auto config =
new EventBase() FlipperInitConfig{DeviceData{}, new EventBase(), new EventBase()};
}; auto instance = std::make_shared<FlipperConnectionManagerImpl>(
auto instance = std::make_shared<FlipperConnectionManagerImpl>(config, state, contextStore); config, state, contextStore);
instance->start(); instance->start();
} }
TEST_F(FlipperConnectionManagerImplTerminationTest, testStartedEventBaseDoesntHang) { TEST_F(
FlipperConnectionManagerImplTerminationTest,
testStartedEventBaseDoesntHang) {
auto flipperEventBase = new EventBase(); auto flipperEventBase = new EventBase();
auto connectionEventBase = new EventBase(); auto connectionEventBase = new EventBase();
auto flipperThread = std::thread([flipperEventBase](){ auto flipperThread =
flipperEventBase->loopForever(); std::thread([flipperEventBase]() { flipperEventBase->loopForever(); });
}); auto connectionThread = std::thread(
auto connectionThread = std::thread([connectionEventBase](){ [connectionEventBase]() { connectionEventBase->loopForever(); });
connectionEventBase->loopForever(); auto config =
}); FlipperInitConfig{DeviceData{}, flipperEventBase, connectionEventBase};
auto config = FlipperInitConfig { auto instance = std::make_shared<FlipperConnectionManagerImpl>(
DeviceData {}, config, state, contextStore);
flipperEventBase,
connectionEventBase
};
auto instance = std::make_shared<FlipperConnectionManagerImpl>(config, state, contextStore);
instance->start(); instance->start();