int main(int argc, char **argv) {
ECC_Start();
SetupEnvironment();
fPrintToDebugLog = false; // don't want to write to debug.log file
benchmark::BenchRunner::RunAll();
ECC_Stop();
}
int main(int argc, char** argv)
{
SetupBenchArgs();
std::string error;
if (!gArgs.ParseParameters(argc, argv, error)) {
fprintf(stderr, "Error parsing command line arguments: %s\n", error.c_str());
return EXIT_FAILURE;
}
if (HelpRequested(gArgs)) {
std::cout << gArgs.GetHelpMessage();
return EXIT_SUCCESS;
}
// Set the datadir after parsing the bench options
const fs::path bench_datadir{SetDataDir()};
SHA256AutoDetect();
RandomInit();
ECC_Start();
SetupEnvironment();
int64_t evaluations = gArgs.GetArg("-evals", DEFAULT_BENCH_EVALUATIONS);
std::string regex_filter = gArgs.GetArg("-filter", DEFAULT_BENCH_FILTER);
std::string scaling_str = gArgs.GetArg("-scaling", DEFAULT_BENCH_SCALING);
bool is_list_only = gArgs.GetBoolArg("-list", false);
double scaling_factor;
if (!ParseDouble(scaling_str, &scaling_factor)) {
fprintf(stderr, "Error parsing scaling factor as double: %s\n", scaling_str.c_str());
return EXIT_FAILURE;
}
std::unique_ptr<benchmark::Printer> printer(new benchmark::ConsolePrinter());
std::string printer_arg = gArgs.GetArg("-printer", DEFAULT_BENCH_PRINTER);
if ("plot" == printer_arg) {
printer.reset(new benchmark::PlotlyPrinter(
gArgs.GetArg("-plot-plotlyurl", DEFAULT_PLOT_PLOTLYURL),
gArgs.GetArg("-plot-width", DEFAULT_PLOT_WIDTH),
gArgs.GetArg("-plot-height", DEFAULT_PLOT_HEIGHT)));
}
benchmark::BenchRunner::RunAll(*printer, evaluations, scaling_factor, regex_filter, is_list_only);
fs::remove_all(bench_datadir);
ECC_Stop();
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
#ifdef WIN32
util::WinCmdLineArgs winArgs;
std::tie(argc, argv) = winArgs.get();
#endif
SetupEnvironment();
RandomInit();
try {
if (!WalletAppInit(argc, argv)) return EXIT_FAILURE;
} catch (const std::exception& e) {
PrintExceptionContinue(&e, "WalletAppInit()");
return EXIT_FAILURE;
} catch (...) {
PrintExceptionContinue(nullptr, "WalletAppInit()");
return EXIT_FAILURE;
}
std::string method {};
for(int i = 1; i < argc; ++i) {
if (!IsSwitchChar(argv[i][0])) {
if (!method.empty()) {
fprintf(stderr, "Error: two methods provided (%s and %s). Only one method should be provided.\n", method.c_str(), argv[i]);
return EXIT_FAILURE;
}
method = argv[i];
}
}
if (method.empty()) {
fprintf(stderr, "No method provided. Run `bitcoin-wallet -help` for valid methods.\n");
return EXIT_FAILURE;
}
// A name must be provided when creating a file
if (method == "create" && !gArgs.IsArgSet("-wallet")) {
fprintf(stderr, "Wallet name must be provided when creating a new wallet.\n");
return EXIT_FAILURE;
}
std::string name = gArgs.GetArg("-wallet", "");
ECCVerifyHandle globalVerifyHandle;
ECC_Start();
if (!WalletTool::ExecuteWalletToolFunc(method, name))
return EXIT_FAILURE;
ECC_Stop();
return EXIT_SUCCESS;
}
int
main(int argc, char** argv)
{
ECC_Start();
ECCVerifyHandle verifyHandle;
BLSInit();
SetupEnvironment();
fPrintToDebugLog = false; // don't want to write to debug.log file
benchmark::BenchRunner::RunAll();
// need to be called before global destructors kick in (PoolAllocator is needed due to many BLSSecretKeys)
CleanupBLSDkgTests();
CleanupBLSTests();
ECC_Stop();
}
// This is all you need to run all the tests
int main(int argc, char *argv[])
{
ECC_Start();
SetupEnvironment();
SetupNetworking();
SelectParams(CBaseChainParams::MAIN);
noui_connect();
bool fInvalid = false;
// Don't remove this, it's needed to access
// QCoreApplication:: in the tests
QCoreApplication app(argc, argv);
app.setApplicationName("Dash-Qt-test");
SSL_library_init();
URITests test1;
if (QTest::qExec(&test1) != 0)
fInvalid = true;
#ifdef ENABLE_WALLET
PaymentServerTests test2;
if (QTest::qExec(&test2) != 0)
fInvalid = true;
#endif
RPCNestedTests test3;
if (QTest::qExec(&test3) != 0)
fInvalid = true;
CompatTests test4;
if (QTest::qExec(&test4) != 0)
fInvalid = true;
TrafficGraphDataTests test5;
if (QTest::qExec(&test5) != 0)
fInvalid = true;
ECC_Stop();
return fInvalid;
}
int
main(int argc, char** argv)
{
SetupBenchArgs();
gArgs.ParseParameters(argc, argv);
if (HelpRequested(gArgs)) {
std::cout << gArgs.GetHelpMessage();
return 0;
}
SHA256AutoDetect();
RandomInit();
ECC_Start();
SetupEnvironment();
int64_t evaluations = gArgs.GetArg("-evals", DEFAULT_BENCH_EVALUATIONS);
std::string regex_filter = gArgs.GetArg("-filter", DEFAULT_BENCH_FILTER);
std::string scaling_str = gArgs.GetArg("-scaling", DEFAULT_BENCH_SCALING);
bool is_list_only = gArgs.GetBoolArg("-list", false);
double scaling_factor = boost::lexical_cast<double>(scaling_str);
std::unique_ptr<benchmark::Printer> printer(new benchmark::ConsolePrinter());
std::string printer_arg = gArgs.GetArg("-printer", DEFAULT_BENCH_PRINTER);
if ("plot" == printer_arg) {
printer.reset(new benchmark::PlotlyPrinter(
gArgs.GetArg("-plot-plotlyurl", DEFAULT_PLOT_PLOTLYURL),
gArgs.GetArg("-plot-width", DEFAULT_PLOT_WIDTH),
gArgs.GetArg("-plot-height", DEFAULT_PLOT_HEIGHT)));
}
benchmark::BenchRunner::RunAll(*printer, evaluations, scaling_factor, regex_filter, is_list_only);
ECC_Stop();
}
BasicTestingSetup::~BasicTestingSetup()
{
ECC_Stop();
}
BasicTestingSetup::~BasicTestingSetup()
{
ECC_Stop();
g_connman.reset();
}
BasicTestingSetup::~BasicTestingSetup()
{
fs::remove_all(m_path_root);
ECC_Stop();
}
int main(int argc, char** argv)
{
struct event_base* base;
struct evhttp* http;
struct evhttp_bound_socket* handle;
unsigned short port = 15520;
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
return (1);
base = event_base_new();
if (!base) {
fprintf(stderr, "Couldn't create an event_base: exiting\n");
return 1;
}
http = evhttp_new(base);
evhttp_set_cb(http, "/led/blink", led_blink, NULL);
handle = evhttp_bind_socket_with_handle(http, "0.0.0.0", port);
//TODO: factor out thread
std::thread cmdThread([&]() {
//TODO, the locking is to broad at the moment
// during executing a command the queue is locked
// and therefore no new commands can be added
// copy the command and callback and release the lock
// would be a solution
std::unique_lock<std::mutex> lock(cs_queue);
while (!stopThread) {
while (!notified) { // loop to avoid spurious wakeups
queueCondVar.wait(lock);
}
while (!cmdQueue.empty()) {
std::string cmdOut;
t_cmdCB cmdCB = cmdQueue.front();
std::string cmd = std::get<0>(cmdCB);
std::string password = std::get<1>(cmdCB);
if (!password.empty())
{
std::string base64str;
std::string unencryptedJson;
try
{
DBB::encryptAndEncodeCommand(cmd, password, base64str);
if (!DBB::sendCommand(base64str, cmdOut))
unencryptedJson = "sending command failed";
else
DBB::decryptAndDecodeCommand(cmdOut, password, unencryptedJson);
}
catch (const std::exception& ex) {
unencryptedJson = "response decryption failed: "+cmdOut;
}
cmdOut = unencryptedJson;
}
else
{
DBB::sendCommand(cmd, cmdOut);
}
std::get<2>(cmdCB)(cmdOut);
cmdQueue.pop();
}
notified = false;
}
});
//create a thread for the http handling
std::thread usbCheckThread([&]() {
while(1)
{
//check devices
if (!DBB::isConnectionOpen())
{
if (DBB::openConnection())
{
#ifdef DBB_ENABLE_QT
//TODO, check if this requires locking
if (widget)
widget->deviceStateHasChanged(true);
#endif
}
else
{
#ifdef DBB_ENABLE_QT
if (widget)
widget->deviceStateHasChanged(false);
#endif
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
});
ECC_Start();
#ifdef DBB_ENABLE_QT
#if QT_VERSION > 0x050100
// Generate high-dpi pixmaps
QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
#endif
//create a thread for the http handling
std::thread httpThread([&]() {
event_base_dispatch(base);
});
QApplication app(argc, argv);
widget = new DBBDaemonGui(0);
widget->show();
app.exec();
#else
//directly start libevents main run loop
event_base_dispatch(base);
#endif
ECC_Stop();
exit(1);
}
~Secp256k1Init() {
ECC_Stop();
}
BasicTestingSetup::~BasicTestingSetup()
{
ECC_Stop();
delete pzcashParams;
}