openclaw/deskflow
1
0
Fork 0
Code Issues Pull Requests Actions 17 Packages Projects Releases Wiki Activity

refactor: port ArgParserTests to QtTests

Browse Source
This commit is contained in:
sithlord48
2025-04-05 17:22:14 -04:00
committed by Nick Bolton
parent 7fa326234e
commit a2acfb0678
4 changed files with 242 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

240
src/test/unittests/deskflow/ArgParserTests.cpp
View File

@ -1,240 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2014 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#include <array>
#include <functional>
#include "common/Constants.h"
#include "deskflow/ArgParser.h"
#include "deskflow/ArgsBase.h"
#include "deskflow/ClientArgs.h"
#include "deskflow/ServerArgs.h"
#include <gtest/gtest.h>
TEST(ArgParserTests, isArg_abbreviationsArg_returnTrue)
{
int i = 1;
const int argc = 2;
const char *argv[argc] = {"stub", "-t"};
bool result = ArgParser::isArg(i, argc, argv, "-t", nullptr);
EXPECT_EQ(true, result);
}
TEST(ArgParserTests, isArg_fullArg_returnTrue)
{
int i = 1;
const int argc = 2;
const char *argv[argc] = {"stub", "--test"};
bool result = ArgParser::isArg(i, argc, argv, nullptr, "--test");
EXPECT_EQ(true, result);
}
TEST(ArgParserTests, isArg_missingArgs_returnFalse)
{
int i = 1;
const int argc = 2;
const char *argv[argc] = {"stub", "-t"};
static deskflow::ArgsBase argsBase;
ArgParser argParser(nullptr);
argParser.setArgsBase(argsBase);
bool result = ArgParser::isArg(i, argc, argv, "-t", nullptr, 1);
EXPECT_FALSE(result);
EXPECT_EQ(true, argsBase.m_shouldExitFail);
}
TEST(ArgParserTests, searchDoubleQuotes_doubleQuotedArg_returnTrue)
{
std::string command("\"stub\"");
size_t left = 0;
size_t right = 0;
bool result = ArgParser::searchDoubleQuotes(command, left, right);
EXPECT_EQ(true, result);
EXPECT_EQ(0, left);
EXPECT_EQ(5, right);
}
TEST(ArgParserTests, searchDoubleQuotes_noDoubleQuotedArg_returnfalse)
{
std::string command("stub");
size_t left = 0;
size_t right = 0;
bool result = ArgParser::searchDoubleQuotes(command, left, right);
EXPECT_FALSE(result);
EXPECT_EQ(0, left);
EXPECT_EQ(0, right);
}
TEST(ArgParserTests, searchDoubleQuotes_oneDoubleQuoteArg_returnfalse)
{
std::string command("\"stub");
size_t left = 0;
size_t right = 0;
bool result = ArgParser::searchDoubleQuotes(command, left, right);
EXPECT_FALSE(result);
EXPECT_EQ(0, left);
EXPECT_EQ(0, right);
}
TEST(ArgParserTests, splitCommandString_oneArg_returnArgv)
{
std::string command("stub");
std::vector<std::string> argv;
ArgParser::splitCommandString(command, argv);
EXPECT_EQ(1, argv.size());
EXPECT_EQ("stub", argv.at(0));
}
TEST(ArgParserTests, splitCommandString_twoArgs_returnArgv)
{
std::string command("stub1 stub2");
std::vector<std::string> argv;
ArgParser::splitCommandString(command, argv);
EXPECT_EQ(2, argv.size());
EXPECT_EQ("stub1", argv.at(0));
EXPECT_EQ("stub2", argv.at(1));
}
TEST(ArgParserTests, splitCommandString_doubleQuotedArgs_returnArgv)
{
std::string command("\"stub1\" stub2 \"stub3\"");
std::vector<std::string> argv;
ArgParser::splitCommandString(command, argv);
EXPECT_EQ(3, argv.size());
EXPECT_EQ("stub1", argv.at(0));
EXPECT_EQ("stub2", argv.at(1));
EXPECT_EQ("stub3", argv.at(2));
}
TEST(ArgParserTests, splitCommandString_spaceDoubleQuotedArgs_returnArgv)
{
std::string command("\"stub1\" stub2 \"stub3 space\"");
std::vector<std::string> argv;
ArgParser::splitCommandString(command, argv);
EXPECT_EQ(3, argv.size());
EXPECT_EQ("stub1", argv.at(0));
EXPECT_EQ("stub2", argv.at(1));
EXPECT_EQ("stub3 space", argv.at(2));
}
TEST(ArgParserTests, getArgv_stringArray_return2DArray)
{
std::vector<std::string> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
argArray.push_back("stub3 space");
const char **argv = ArgParser::getArgv(argArray);
std::string row1(argv[0]);
std::string row2(argv[1]);
std::string row3(argv[2]);
EXPECT_EQ("stub1", row1);
EXPECT_EQ("stub2", row2);
EXPECT_EQ("stub3 space", row3);
delete[] argv;
}
TEST(ArgParserTests, assembleCommand_stringArray_returnCommand)
{
std::vector<std::string> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
std::string command = ArgParser::assembleCommand(argArray);
EXPECT_EQ("stub1 stub2", command);
}
TEST(ArgParserTests, assembleCommand_ignoreSecondArg_returnCommand)
{
std::vector<std::string> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
std::string command = ArgParser::assembleCommand(argArray, "stub2");
EXPECT_EQ("stub1", command);
}
TEST(ArgParserTests, assembleCommand_ignoreSecondArgWithOneParameter_returnCommand)
{
std::vector<std::string> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
argArray.push_back("stub3");
argArray.push_back("stub4");
std::string command = ArgParser::assembleCommand(argArray, "stub2", 1);
EXPECT_EQ("stub1 stub4", command);
}
TEST(ArgParserTests, assembleCommand_stringArrayWithSpace_returnCommand)
{
std::vector<std::string> argArray;
argArray.push_back("stub1 space");
argArray.push_back("stub2");
argArray.push_back("stub3 space");
std::string command = ArgParser::assembleCommand(argArray);
EXPECT_EQ("\"stub1 space\" stub2 \"stub3 space\"", command);
}
TEST(ArgParserTests, parseServerArgs_parses_each_category)
{
ArgParser parser(nullptr);
deskflow::ServerArgs args;
args.m_daemon = false;
char const *argv[] = {
"deskflow", "--help"
#if WINAPI_XWINDOWS
,
"--no-xinitthreads"
#endif
,
"--res-w", "888"
};
EXPECT_TRUE(parser.parseServerArgs(args, sizeof(argv) / sizeof(argv[0]), argv));
EXPECT_EQ(args.m_shouldExitOk, true);
}
TEST(ArgParserTests, parseClientArgs_parses_single_help)
{
ArgParser parser(nullptr);
deskflow::ClientArgs args;
args.m_daemon = false;
char const *argv[] = {
kAppId,
"--help"
#if WINAPI_XWINDOWS
,
"--no-xinitthreads"
#endif
,
"--res-w",
"888",
"127.0.0.1"
};
EXPECT_TRUE(parser.parseClientArgs(args, sizeof(argv) / sizeof(argv[0]), argv));
EXPECT_EQ(args.m_shouldExitOk, true);
}

202
src/unittests/deskflow/ArgParserTests.cpp Normal file
View File

@ -0,0 +1,202 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2025 Chris Rizzitello <sithlord48@gmail.com>
* SPDX-FileCopyrightText: (C) 2014 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#include "ArgParserTests.h"
#include "../../lib/deskflow/ArgsBase.h"
#include "../../lib/deskflow/ClientArgs.h"
#include "../../lib/deskflow/ServerArgs.h"
// This file is generated at build time
#include <common/Constants.h>
void ArgParserTests::initTestCase()
{
m_arch.init();
m_log.setFilter(kDEBUG2);
}
void ArgParserTests::isArg()
{
int i = 1;
const int argc = 2;
const char *argShort[argc] = {"stub", "-t"};
QVERIFY(ArgParser::isArg(i, argc, argShort, "-t", NULL));
const char *argLong[argc] = {"stub", "--test"};
QVERIFY(ArgParser::isArg(i, argc, argLong, NULL, "--test"));
}
void ArgParserTests::missingArg()
{
int i = 1;
const int argc = 2;
const char *argv[argc] = {"stub", "-t"};
static deskflow::ArgsBase argsBase;
m_parser.setArgsBase(argsBase);
QVERIFY(!ArgParser::isArg(i, argc, argv, "-t", NULL, 1));
QVERIFY(argsBase.m_shouldExitFail);
}
void ArgParserTests::withQuotes()
{
std::string command("\"stub\"");
size_t left = 0;
size_t right = 0;
QVERIFY(ArgParser::searchDoubleQuotes(command, left, right));
QCOMPARE(left, 0);
QCOMPARE(right, 5);
command = "stub";
left = 0;
right = 0;
QVERIFY(!ArgParser::searchDoubleQuotes(command, left, right));
QCOMPARE(0, left);
QCOMPARE(0, right);
command = "\"stub";
left = 0;
right = 0;
QVERIFY(!ArgParser::searchDoubleQuotes(command, left, right));
QCOMPARE(left, 0);
QCOMPARE(right, 0);
}
void ArgParserTests::splitCommand()
{
std::string command("stub");
std::vector<std::string> argv;
ArgParser::splitCommandString(command, argv);
QCOMPARE(argv.size(), 1);
QCOMPARE(argv.at(0), "stub");
command = "stub1 stub2";
argv.resize(0);
ArgParser::splitCommandString(command, argv);
QCOMPARE(2, argv.size());
QCOMPARE(argv.at(0), "stub1");
QCOMPARE(argv.at(1), "stub2");
command = "stub1 stub2 stub3";
argv.resize(0);
ArgParser::splitCommandString(command, argv);
QCOMPARE(3, argv.size());
QCOMPARE(argv.at(0), "stub1");
QCOMPARE(argv.at(1), "stub2");
QCOMPARE(argv.at(2), "stub3");
command = "\"stub1\" stub2 \"stub3 space\"";
argv.resize(0);
ArgParser::splitCommandString(command, argv);
QCOMPARE(3, argv.size());
QCOMPARE(argv.at(0), "stub1");
QCOMPARE(argv.at(1), "stub2");
QCOMPARE(argv.at(2), "stub3 space");
}
void ArgParserTests::getArgv()
{
std::vector<std::string> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
argArray.push_back("stub3 space");
const char **argv = ArgParser::getArgv(argArray);
std::string row1(argv[0]);
std::string row2(argv[1]);
std::string row3(argv[2]);
QCOMPARE(row1, "stub1");
QCOMPARE(row2, "stub2");
QCOMPARE(row3, "stub3 space");
delete[] argv;
}
void ArgParserTests::assembleCommand()
{
std::vector<std::string> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
std::string command = ArgParser::assembleCommand(argArray);
QCOMPARE(command, "stub1 stub2");
argArray.resize(0);
argArray.push_back("stub1");
argArray.push_back("stub2");
command = ArgParser::assembleCommand(argArray, "stub2");
QCOMPARE(command, "stub1");
argArray.resize(0);
argArray.push_back("stub1");
argArray.push_back("stub2");
argArray.push_back("stub3");
argArray.push_back("stub4");
command = ArgParser::assembleCommand(argArray, "stub2", 1);
QCOMPARE(command, "stub1 stub4");
argArray.resize(0);
argArray.push_back("stub1 space");
argArray.push_back("stub2");
argArray.push_back("stub3 space");
command = ArgParser::assembleCommand(argArray);
QCOMPARE(command, "\"stub1 space\" stub2 \"stub3 space\"");
}
void ArgParserTests::serverArgs()
{
deskflow::ServerArgs args;
args.m_daemon = false;
char const *argv[] = {
"deskflow", "--help"
#if WINAPI_XWINDOWS
,
"--no-xinitthreads"
#endif
,
"--res-w", "888"
};
QVERIFY(m_parser.parseServerArgs(args, sizeof(argv) / sizeof(argv[0]), argv));
QVERIFY(args.m_shouldExitOk);
}
void ArgParserTests::clientArgs()
{
deskflow::ClientArgs args;
args.m_daemon = false;
char const *argv[] = {
kAppId,
"--help"
#if WINAPI_XWINDOWS
,
"--no-xinitthreads"
#endif
,
"--res-w",
"888",
"127.0.0.1"
};
QVERIFY(m_parser.parseClientArgs(args, sizeof(argv) / sizeof(argv[0]), argv));
QVERIFY(args.m_shouldExitOk);
}
QTEST_MAIN(ArgParserTests)

32
src/unittests/deskflow/ArgParserTests.h Normal file
View File

@ -0,0 +1,32 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2025 Chris Rizzitello <sithlord48@gmail.com>
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#include "../../lib/deskflow/ArgParser.h"
#include "base/Log.h"
#include <QTest>
class ArgParserTests : public QObject
{
Q_OBJECT
private slots:
void initTestCase();
// Test are run in order top to bottom
void isArg();
void missingArg();
void withQuotes();
void splitCommand();
void getArgv();
void assembleCommand();
void serverArgs();
void clientArgs();
private:
Arch m_arch;
Log m_log;
ArgParser m_parser = ArgParser(nullptr);
};

8
src/unittests/deskflow/CMakeLists.txt
View File

@ -5,6 +5,14 @@ if(WIN32)
set(extra_libs version)
endif()
create_test(
NAME ArgParserTests
DEPENDS app
LIBS arch base ${extra_libs}
SOURCE ArgParserTests.cpp
WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/src/lib/deskflow"
)
create_test(
NAME ConfigTests
DEPENDS app