QApplicationStatus::QApplicationStatus(QObject *parent) :
AbstractServiceImplementation(parent),
m_statusUri(""),
m_statusSocketState(Down),
m_connected(false),
m_connectionState(Disconnected),
m_error(NoError),
m_errorString(""),
m_running(false),
m_synced(false),
m_channels(MotionChannel | ConfigChannel | IoChannel | TaskChannel | InterpChannel),
m_context(NULL),
m_statusSocket(NULL),
m_statusHeartbeatTimer(new QTimer(this))
{
connect(m_statusHeartbeatTimer, SIGNAL(timeout()),
this, SLOT(statusHeartbeatTimerTick()));
connect(this, SIGNAL(taskChanged(QJsonObject)),
this, SLOT(updateRunning(QJsonObject)));
connect(this, SIGNAL(interpChanged(QJsonObject)),
this, SLOT(updateRunning(QJsonObject)));
initializeObject(MotionChannel);
initializeObject(ConfigChannel);
initializeObject(IoChannel);
initializeObject(TaskChannel);
initializeObject(InterpChannel);
}
void QApplicationStatus::updateState(QApplicationStatus::State state, QApplicationStatus::ConnectionError error, const QString &errorString)
{
if (state != m_connectionState)
{
if (m_connected) // we are not connected anymore
{
stopStatusHeartbeat();
clearSync();
m_connected = false;
emit connectedChanged(false);
}
else if (state == Connected) {
m_connected = true;
emit connectedChanged(true);
}
m_connectionState = state;
emit connectionStateChanged(m_connectionState);
if ((state == Disconnected) || (state == Error)) {
initializeObject(MotionChannel);
initializeObject(ConfigChannel);
initializeObject(IoChannel);
initializeObject(TaskChannel);
initializeObject(InterpChannel);
}
}
updateError(error, errorString);
}
QApplicationLauncher::QApplicationLauncher(QObject *parent) :
AbstractServiceImplementation(parent),
m_subscribeUri(""),
m_commandUri(""),
m_commandIdentity("launcher"),
m_heartbeatPeriod(3000),
m_connected(false),
m_subscribeSocketState(Service::Down),
m_commandSocketState(Service::Down),
m_connectionState(Service::Disconnected),
m_error(Service::NoError),
m_errorString(""),
m_launchers(QJsonValue(QJsonArray())),
m_synced(false),
m_context(NULL),
m_subscribeSocket(NULL),
m_commandSocket(NULL),
m_commandHeartbeatTimer(new QTimer(this)),
m_subscribeHeartbeatTimer(new QTimer(this)),
m_commandPingOutstanding(false)
{
connect(m_commandHeartbeatTimer, SIGNAL(timeout()),
this, SLOT(commandHeartbeatTimerTick()));
connect(m_subscribeHeartbeatTimer, SIGNAL(timeout()),
this, SLOT(subscribeHeartbeatTimerTick()));
initializeObject();
}
TEST(Constructor, ValidData)
{
Arguments object = initializeObject();
ASSERT_EQ(object.appName(), "AppName");
ASSERT_EQ(object[0], "Argument1");
ASSERT_EQ(object[1], "Argument2");
}
AtomicInteger::AtomicInteger(int32_t val)
{
mNonAtomicValue = 0;
mAtomicValue = 0;
initializeObject();
this->set(val);
}
void QApplicationLauncher::updateState(Service::State state, Service::ConnectionError error, QString errorString)
{
if (state != m_connectionState)
{
if (m_connected) // we are not connected anymore
{
stopSubscribeHeartbeat();
clearSync();
m_connected = false;
emit connectedChanged(false);
}
else if (state == Service::Connected) {
m_connected = true;
emit connectedChanged(true);
}
m_connectionState = state;
emit connectionStateChanged(m_connectionState);
if ((state == Service::Disconnected) || (state == Service::Error)) {
initializeObject();
}
}
updateError(error, errorString);
}
Game* GameLoader::createGame(const QDomElement& element)
{
if (element.tagName()!="game") return nullptr;
Game* game = new Game();
initializeObject(element.firstChildElement("player"), game->player());
QDomNodeList children = element.childNodes();
for (int i=0; i<children.size(); ++i)
{
QDomElement child = children.at(i).toElement();
if (child.tagName()=="npcs")
{
for (NPC* npc: loadNpcs(child))
{
game->npcFactory()->addPrototype(npc->name(), npc);
}
}
}
QString mapSource = element.attribute("startmap");
QString target = element.attribute("target");
game->changeMap(mapSource, target);
return game;
}
void ApplicationLauncher::unsyncStatus()
{
m_synced = false;
emit syncedChanged(m_synced);
initializeObject();
emit launchersChanged();
}
QList<NPC*> GameLoader::loadNpcs(const QDomElement& element)
{
QList<NPC*> npcs;
QString source = element.attribute("source");
if (!source.isNull())
{
QDomDocument document = load(path()+"/"+source);
npcs = loadNpcs(document.documentElement());
_paths.pop();
return npcs;
}
QDomNodeList children = element.childNodes();
for (int i=0; i<children.size(); ++i)
{
QDomElement child = children.at(i).toElement();
if (child.tagName()=="npc")
{
NPC* npc = new NPC();
npc->setName(child.attribute("name"));
initializeObject(child, npc);
npcs << npc;
}
}
return npcs;
}
void ApplicationLauncher::handleLauncherFullUpdateMessage(const QByteArray &topic, const Container &rx)
{
Q_UNUSED(topic);
initializeObject(); // clear old value
MachinetalkService::recurseMessage(rx, m_launcherObject, m_temporaryDir->path(), QStringLiteral("launcher"));
emit launchersChanged();
}
TEST(CoppyConstructor, ValidData)
{
Arguments object = initializeObject();
Arguments copyObject(object);
ASSERT_EQ(copyObject.appName(), object.appName());
ASSERT_EQ(copyObject[0],object[0]);
ASSERT_EQ(copyObject[1],object[1]);
}
ApplicationLauncher::ApplicationLauncher(QObject *parent) :
application::LauncherBase(parent),
m_launcherObject(nullptr),
m_synced(false),
m_temporaryDir(nullptr)
{
initializeObject();
createTemporaryDir();
addLauncherTopic("launcher");
}
TEST(AssignmentOperatorObject, ValidData)
{
char * args[1] = {(char*)"ceva"};
Arguments object = initializeObject();
Arguments copyObject(1, args);
copyObject = object;
ASSERT_EQ(copyObject.appName(), object.appName());
ASSERT_EQ(copyObject[0], object[0]);
ASSERT_EQ(copyObject[1], object[1]);
}
void QApplicationStatus::unsubscribe()
{
m_statusSocketState = Down;
foreach (QString subscription, m_subscriptions)
{
m_statusSocket->unsubscribeFrom(subscription);
if (subscription == "motion") {
initializeObject(MotionChannel);
}
else if (subscription == "config") {
initializeObject(ConfigChannel);
}
else if (subscription == "io") {
initializeObject(IoChannel);
}
else if (subscription == "task") {
initializeObject(TaskChannel);
}
else if (subscription == "interp") {
initializeObject(InterpChannel);
}
}
AtomicInteger::AtomicInteger()
{
initializeObject();
}
Entry::Entry(char *l)
{
parser(l);
initializeObject(INVISIBLE);
entry = this;
}
TEST(AssignmentOperator, ValidData)
{
Arguments object = initializeObject();
ASSERT_EQ(object[0], "Argument1");
ASSERT_EQ(object[1], "Argument2");
}
TEST(CountIsEqual, ValidData)
{
Arguments object = initializeObject();
ASSERT_EQ(object.count(), 2);
}
TEST(AppName, ValidData)
{
Arguments object = initializeObject();
ASSERT_EQ(object.appName(), "AppName");
}