Refactor launch server tests

* Move SafemodeConditionContext definition from method to the class
  because GCC2 can't handle it (possibly because the method
  is defined in-line).

Change-Id: If432ddf7fdb044ff5d5b8ca87a20b60489bb7cd7
Reviewed-on: https://review.haiku-os.org/c/haiku/+/10682
Reviewed-by: waddlesplash <[email protected]>
Tested-by: Commit checker robot <[email protected]>
This commit is contained in:
Kacper Kasper
2026-04-07 04:35:59 +00:00
parent 9420780c0a
commit 112776eead
7 changed files with 579 additions and 873 deletions
+149 -184
View File
@@ -4,15 +4,14 @@
*/ */
#include "ConditionsTest.h"
#include <stdlib.h> #include <stdlib.h>
#include <driver_settings.h> #include <driver_settings.h>
#include <String.h> #include <String.h>
#include <cppunit/TestCaller.h> #include <TestSuiteAddon.h>
#include <cppunit/TestSuite.h> #include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "Conditions.h" #include "Conditions.h"
#include "SettingsParser.h" #include "SettingsParser.h"
@@ -30,30 +29,38 @@ public:
static TestConditionContext sConditionContext; static TestConditionContext sConditionContext;
ConditionsTest::ConditionsTest() class ConditionsTest : public CppUnit::TestFixture {
{ CPPUNIT_TEST_SUITE(ConditionsTest);
} CPPUNIT_TEST(TestEmpty);
CPPUNIT_TEST(TestSafemode);
CPPUNIT_TEST(TestFileExists);
CPPUNIT_TEST(TestOr);
CPPUNIT_TEST(TestAnd);
CPPUNIT_TEST(TestNot);
CPPUNIT_TEST_SUITE_END();
Condition* _Condition(const char* string)
{
SettingsParser parser;
BString input("job A {\nif {");
input << string << "\n}\n}\n";
ConditionsTest::~ConditionsTest() BMessage jobs;
{ CPPUNIT_ASSERT_EQUAL(B_OK, parser.Parse(input, jobs));
}
BMessage job;
CPPUNIT_ASSERT_EQUAL(B_OK, jobs.FindMessage("job", 0, &job));
CPPUNIT_ASSERT_EQUAL(2, (int)job.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(BString("A"), BString(job.GetString("name")));
void BMessage message;
ConditionsTest::TestEmpty() CPPUNIT_ASSERT_EQUAL(B_OK, job.FindMessage("if", &message));
{
Condition* condition = _Condition("");
CPPUNIT_ASSERT(condition == NULL);
}
Condition* condition = Conditions::FromMessage(message);
void if (string[0] != '\0')
ConditionsTest::TestSafemode() CPPUNIT_ASSERT(condition != NULL);
{ return condition;
Condition* condition = _Condition("safemode"); }
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(condition->IsConstant(sConditionContext));
class SafemodeConditionContext : public TestConditionContext { class SafemodeConditionContext : public TestConditionContext {
public: public:
@@ -61,166 +68,124 @@ ConditionsTest::TestSafemode()
{ {
return true; return true;
} }
} safemodeContext; };
CPPUNIT_ASSERT(condition->Test(safemodeContext));
CPPUNIT_ASSERT(condition->IsConstant(safemodeContext)); public:
} void TestEmpty()
{
Condition* condition = _Condition("");
CPPUNIT_ASSERT(condition == NULL);
}
void TestSafemode()
{
Condition* condition = _Condition("safemode");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(condition->IsConstant(sConditionContext));
SafemodeConditionContext safemodeContext;
CPPUNIT_ASSERT(condition->Test(safemodeContext));
CPPUNIT_ASSERT(condition->IsConstant(safemodeContext));
}
void TestFileExists()
{
Condition* condition = _Condition("file_exists /boot");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("file_exists /boot/don't fool me!");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
}
void TestOr()
{
Condition* condition = _Condition("or {\n"
"file_exists /boot\n"
"}\n");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("or {\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("or {\n"
"file_exists /boot\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("or {\n"
"not safemode\n"
"file_exists /boot\n"
"}\n");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(condition->IsConstant(sConditionContext));
condition = _Condition("or {\n"
"safemode\n"
"file_exists /boot\n"
"}\n");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
}
void TestAnd()
{
Condition* condition = _Condition("and {\n"
"file_exists /boot\n"
"}\n");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("and {\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("and {\n"
"file_exists /boot\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("and {\n"
"safemode\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(condition->IsConstant(sConditionContext));
condition = _Condition("and {\n"
"not safemode\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("and {\n"
"safemode\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(condition->IsConstant(sConditionContext));
}
void TestNot()
{
Condition* condition = _Condition("not safemode");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
SafemodeConditionContext safemodeContext;
CPPUNIT_ASSERT(!condition->Test(safemodeContext));
}
};
void CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(ConditionsTest, getTestSuiteName());
ConditionsTest::TestFileExists()
{
Condition* condition = _Condition("file_exists /boot");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("file_exists /boot/don't fool me!");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
}
void
ConditionsTest::TestOr()
{
Condition* condition = _Condition("or {\n"
"file_exists /boot\n"
"}\n");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("or {\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("or {\n"
"file_exists /boot\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("or {\n"
"not safemode\n"
"file_exists /boot\n"
"}\n");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(condition->IsConstant(sConditionContext));
condition = _Condition("or {\n"
"safemode\n"
"file_exists /boot\n"
"}\n");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
}
void
ConditionsTest::TestAnd()
{
Condition* condition = _Condition("and {\n"
"file_exists /boot\n"
"}\n");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("and {\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("and {\n"
"file_exists /boot\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("and {\n"
"safemode\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(condition->IsConstant(sConditionContext));
condition = _Condition("and {\n"
"not safemode\n"
"file_exists /nowhere\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(!condition->IsConstant(sConditionContext));
condition = _Condition("and {\n"
"safemode\n"
"}\n");
CPPUNIT_ASSERT(!condition->Test(sConditionContext));
CPPUNIT_ASSERT(condition->IsConstant(sConditionContext));
}
void
ConditionsTest::TestNot()
{
Condition* condition = _Condition("not safemode");
CPPUNIT_ASSERT(condition->Test(sConditionContext));
class SafemodeConditionContext : public TestConditionContext {
public:
bool IsSafeMode() const
{
return true;
}
} safemodeContext;
CPPUNIT_ASSERT(!condition->Test(safemodeContext));
}
/*static*/ void
ConditionsTest::AddTests(BTestSuite& parent)
{
CppUnit::TestSuite& suite = *new CppUnit::TestSuite("ConditionsTest");
suite.addTest(new CppUnit::TestCaller<ConditionsTest>(
"ConditionsTest::TestEmpty", &ConditionsTest::TestEmpty));
suite.addTest(new CppUnit::TestCaller<ConditionsTest>(
"ConditionsTest::TestSafemode", &ConditionsTest::TestSafemode));
suite.addTest(new CppUnit::TestCaller<ConditionsTest>(
"ConditionsTest::TestFileExists", &ConditionsTest::TestFileExists));
suite.addTest(new CppUnit::TestCaller<ConditionsTest>(
"ConditionsTest::TestOr", &ConditionsTest::TestOr));
suite.addTest(new CppUnit::TestCaller<ConditionsTest>(
"ConditionsTest::TestAnd", &ConditionsTest::TestAnd));
suite.addTest(new CppUnit::TestCaller<ConditionsTest>(
"ConditionsTest::TestNot", &ConditionsTest::TestNot));
parent.addTest("ConditionsTest", &suite);
}
Condition*
ConditionsTest::_Condition(const char* string)
{
SettingsParser parser;
BString input("job A {\nif {");
input << string << "\n}\n}\n";
BMessage jobs;
CPPUNIT_ASSERT_EQUAL(B_OK, parser.Parse(input, jobs));
BMessage job;
CPPUNIT_ASSERT_EQUAL(B_OK, jobs.FindMessage("job", 0, &job));
CPPUNIT_ASSERT_EQUAL(2, job.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(BString("A"), BString(job.GetString("name")));
BMessage message;
CPPUNIT_ASSERT_EQUAL(B_OK, job.FindMessage("if", &message));
Condition* condition = Conditions::FromMessage(message);
if (string[0] != '\0')
CPPUNIT_ASSERT(condition != NULL);
return condition;
}
-35
View File
@@ -1,35 +0,0 @@
/*
* Copyright 2015, Axel Dörfler, [email protected].
* Distributed under the terms of the MIT License.
*/
#ifndef CONDITIONS_TEST_H
#define CONDITIONS_TEST_H
#include <TestCase.h>
#include <TestSuite.h>
class Condition;
class ConditionsTest : public CppUnit::TestCase {
public:
ConditionsTest();
virtual ~ConditionsTest();
void TestEmpty();
void TestSafemode();
void TestFileExists();
void TestOr();
void TestAnd();
void TestNot();
static void AddTests(BTestSuite& suite);
private:
Condition* _Condition(const char* string);
};
#endif // CONDITIONS_TEST_H
@@ -4,22 +4,11 @@
*/ */
#include <TestSuite.h>
#include <TestSuiteAddon.h> #include <TestSuiteAddon.h>
#include "ConditionsTest.h"
#include "SettingsParserTest.h"
#include "UtilityTest.h"
const char*
BTestSuite* getTestSuiteName()
getTestSuite()
{ {
BTestSuite* suite = new BTestSuite("LaunchDaemon"); return "LaunchDaemon";
SettingsParserTest::AddTests(*suite);
ConditionsTest::AddTests(*suite);
UtilityTest::AddTests(*suite);
return suite;
} }
+399 -517
View File
@@ -4,529 +4,411 @@
*/ */
#include "SettingsParserTest.h"
#include <stdlib.h> #include <stdlib.h>
#include <driver_settings.h> #include <driver_settings.h>
#include <String.h> #include <String.h>
#include <cppunit/TestCaller.h> #include <TestSuiteAddon.h>
#include <cppunit/TestSuite.h> #include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "SettingsParser.h" #include "SettingsParser.h"
SettingsParserTest::SettingsParserTest() class SettingsParserTest : public CppUnit::TestFixture {
{ CPPUNIT_TEST_SUITE(SettingsParserTest);
} CPPUNIT_TEST(TestConditionsEmpty);
CPPUNIT_TEST(TestConditionsMultiLine);
CPPUNIT_TEST(TestConditionsFlat);
SettingsParserTest::~SettingsParserTest() CPPUNIT_TEST(TestConditionsFlatWithNot);
{ CPPUNIT_TEST(TestConditionsFlatWithArgs);
} CPPUNIT_TEST(TestConditionsFlatWithNotAndArgs);
CPPUNIT_TEST(TestConditionsMultiLineFlatNot);
CPPUNIT_TEST(TestConditionsMultiLineFlatNotWithArgs);
// #pragma mark - conditions CPPUNIT_TEST(TestConditionsMultiLineNot);
CPPUNIT_TEST(TestEventsEmpty);
CPPUNIT_TEST(TestEventsMultiLine);
void CPPUNIT_TEST(TestEventsFlat);
SettingsParserTest::TestConditionsEmpty() CPPUNIT_TEST(TestEventsFlatWithArgs);
{ CPPUNIT_TEST(TestEnvironmentMultiLine);
BMessage message; CPPUNIT_TEST(TestEnvironmentFlat);
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if {\n" CPPUNIT_TEST(TestRunFlat);
"}\n", message)); CPPUNIT_TEST(TestRunMultiLine);
CPPUNIT_ASSERT(message.IsEmpty()); CPPUNIT_TEST(TestRunIfThenElseFlat);
} CPPUNIT_TEST(TestRunIfThenElseMultiLine);
CPPUNIT_TEST_SUITE_END();
void status_t _ParseCondition(const char* text, BMessage& message)
SettingsParserTest::TestConditionsMultiLine() {
{ return _ParseName("if", text, message);
BMessage message; }
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if {\n"
"\tsafemode\n" status_t _ParseEvent(const char* text, BMessage& message)
"\tfile_exists one\n" {
"}\n", message)); return _ParseName("on", text, message);
CPPUNIT_ASSERT_EQUAL(2, message.CountNames(B_ANY_TYPE)); }
BMessage subMessage; status_t _ParseName(const char* name, const char* text, BMessage& message)
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("safemode", &subMessage)); {
CPPUNIT_ASSERT(subMessage.IsEmpty()); SettingsParser parser;
BString input("job A {\n");
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("file_exists", input << text << "\n}\n";
&subMessage));
CPPUNIT_ASSERT_EQUAL(BString("one"), BMessage jobs;
BString(subMessage.GetString("args", 0, "-"))); status_t status = parser.Parse(input, jobs);
CPPUNIT_ASSERT_EQUAL(1, subMessage.CountNames(B_ANY_TYPE)); if (status != B_OK)
} return status;
BMessage job;
void status = jobs.FindMessage("job", 0, &job);
SettingsParserTest::TestConditionsFlat() if (status != B_OK)
{ return status;
BMessage message;
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if safemode\n", message)); CPPUNIT_ASSERT_EQUAL(2, (int)job.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(1, message.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT_EQUAL(BString("A"), BString(job.GetString("name")));
BMessage args; return job.FindMessage(name, &message);
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("safemode", &args)); }
CPPUNIT_ASSERT(args.IsEmpty());
} int32 _ArrayCount(BMessage& message, const char* name)
{
int32 found;
void if (message.GetInfo(name, NULL, &found, NULL) != B_OK)
SettingsParserTest::TestConditionsFlatWithNot() return 0;
{
BMessage message; return found;
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if not safemode\n", message)); }
CPPUNIT_ASSERT_EQUAL(1, message.CountNames(B_ANY_TYPE));
public:
BMessage subMessage; void TestConditionsEmpty()
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("not", {
&subMessage)); BMessage message;
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if {\n"
BMessage args; "}\n", message));
CPPUNIT_ASSERT_EQUAL(B_OK, subMessage.FindMessage("safemode", &args)); CPPUNIT_ASSERT(message.IsEmpty());
CPPUNIT_ASSERT(args.IsEmpty()); }
}
void TestConditionsMultiLine()
{
void BMessage message;
SettingsParserTest::TestConditionsFlatWithArgs() CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if {\n"
{ "\tsafemode\n"
BMessage message; "\tfile_exists one\n"
CPPUNIT_ASSERT_EQUAL(B_OK, "}\n", message));
_ParseCondition("if file_exists one\n", message)); CPPUNIT_ASSERT_EQUAL(2, (int)message.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(1, message.CountNames(B_ANY_TYPE));
BMessage subMessage;
BMessage args; CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("safemode", &subMessage));
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("file_exists", &args)); CPPUNIT_ASSERT(subMessage.IsEmpty());
CPPUNIT_ASSERT_EQUAL(BString("one"),
BString(args.GetString("args", 0, "-"))); CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("file_exists",
CPPUNIT_ASSERT_EQUAL(1, args.CountNames(B_ANY_TYPE)); &subMessage));
} CPPUNIT_ASSERT_EQUAL(BString("one"),
BString(subMessage.GetString("args", 0, "-")));
CPPUNIT_ASSERT_EQUAL(1, (int)subMessage.CountNames(B_ANY_TYPE));
void }
SettingsParserTest::TestConditionsFlatWithNotAndArgs()
{ void TestConditionsFlat()
BMessage message; {
CPPUNIT_ASSERT_EQUAL(B_OK, BMessage message;
_ParseCondition("if not file_exists one\n", message)); CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if safemode\n", message));
CPPUNIT_ASSERT_EQUAL(1, message.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT_EQUAL(1, (int)message.CountNames(B_ANY_TYPE));
BMessage subMessage; BMessage args;
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("not", CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("safemode", &args));
&subMessage)); CPPUNIT_ASSERT(args.IsEmpty());
}
BMessage args;
CPPUNIT_ASSERT_EQUAL(B_OK, subMessage.FindMessage("file_exists", &args)); void TestConditionsFlatWithNot()
CPPUNIT_ASSERT_EQUAL(BString("one"), {
BString(args.GetString("args", 0, "-"))); BMessage message;
CPPUNIT_ASSERT_EQUAL(1, args.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if not safemode\n", message));
} CPPUNIT_ASSERT_EQUAL(1, (int)message.CountNames(B_ANY_TYPE));
BMessage subMessage;
void CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("not",
SettingsParserTest::TestConditionsMultiLineFlatNot() &subMessage));
{
BMessage message; BMessage args;
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if {\n" CPPUNIT_ASSERT_EQUAL(B_OK, subMessage.FindMessage("safemode", &args));
"\tnot safemode\n" CPPUNIT_ASSERT(args.IsEmpty());
"}\n", message)); }
BMessage subMessage; void TestConditionsFlatWithArgs()
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("not", {
&subMessage)); BMessage message;
CPPUNIT_ASSERT_EQUAL(1, message.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT_EQUAL(B_OK,
_ParseCondition("if file_exists one\n", message));
BMessage args; CPPUNIT_ASSERT_EQUAL(1, (int)message.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(B_OK, subMessage.FindMessage("safemode", &args));
CPPUNIT_ASSERT_EQUAL(1, subMessage.CountNames(B_ANY_TYPE)); BMessage args;
CPPUNIT_ASSERT(args.IsEmpty()); CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("file_exists", &args));
} CPPUNIT_ASSERT_EQUAL(BString("one"),
BString(args.GetString("args", 0, "-")));
CPPUNIT_ASSERT_EQUAL(1, (int)args.CountNames(B_ANY_TYPE));
void }
SettingsParserTest::TestConditionsMultiLineFlatNotWithArgs()
{ void TestConditionsFlatWithNotAndArgs()
BMessage message; {
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if {\n" BMessage message;
"\tnot file_exists one two\n" CPPUNIT_ASSERT_EQUAL(B_OK,
"}\n", message)); _ParseCondition("if not file_exists one\n", message));
CPPUNIT_ASSERT_EQUAL(1, (int)message.CountNames(B_ANY_TYPE));
BMessage subMessage;
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("not", BMessage subMessage;
&subMessage)); CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("not",
&subMessage));
BMessage args;
CPPUNIT_ASSERT_EQUAL(B_OK, subMessage.FindMessage("file_exists", &args)); BMessage args;
CPPUNIT_ASSERT_EQUAL(BString("one"), CPPUNIT_ASSERT_EQUAL(B_OK, subMessage.FindMessage("file_exists", &args));
BString(args.GetString("args", 0, "-"))); CPPUNIT_ASSERT_EQUAL(BString("one"),
CPPUNIT_ASSERT_EQUAL(BString("two"), BString(args.GetString("args", 0, "-")));
BString(args.GetString("args", 1, "-"))); CPPUNIT_ASSERT_EQUAL(1, (int)args.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(1, args.CountNames(B_ANY_TYPE)); }
CPPUNIT_ASSERT_EQUAL(2, _ArrayCount(args, "args"));
} void TestConditionsMultiLineFlatNot()
{
BMessage message;
void CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if {\n"
SettingsParserTest::TestConditionsMultiLineNot() "\tnot safemode\n"
{ "}\n", message));
BMessage message;
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if {\n" BMessage subMessage;
"\tnot {\n" CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("not",
"\t\tsafemode\n" &subMessage));
"\t}\n" CPPUNIT_ASSERT_EQUAL(1, (int)message.CountNames(B_ANY_TYPE));
"}\n", message));
BMessage args;
BMessage subMessage; CPPUNIT_ASSERT_EQUAL(B_OK, subMessage.FindMessage("safemode", &args));
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("not", &subMessage)); CPPUNIT_ASSERT_EQUAL(1, (int)subMessage.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT(args.IsEmpty());
BMessage args; }
CPPUNIT_ASSERT_EQUAL(B_OK, subMessage.FindMessage("safemode", &args));
CPPUNIT_ASSERT(args.IsEmpty()); void TestConditionsMultiLineFlatNotWithArgs()
} {
BMessage message;
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if {\n"
// #pragma mark - events "\tnot file_exists one two\n"
"}\n", message));
void BMessage subMessage;
SettingsParserTest::TestEventsEmpty() CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("not",
{ &subMessage));
BMessage message;
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseEvent("on {\n" BMessage args;
"}\n", message)); CPPUNIT_ASSERT_EQUAL(B_OK, subMessage.FindMessage("file_exists", &args));
CPPUNIT_ASSERT(message.IsEmpty()); CPPUNIT_ASSERT_EQUAL(BString("one"),
} BString(args.GetString("args", 0, "-")));
CPPUNIT_ASSERT_EQUAL(BString("two"),
BString(args.GetString("args", 1, "-")));
void CPPUNIT_ASSERT_EQUAL(1, (int)args.CountNames(B_ANY_TYPE));
SettingsParserTest::TestEventsMultiLine() CPPUNIT_ASSERT_EQUAL(2, (int)_ArrayCount(args, "args"));
{ }
BMessage message;
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseEvent("on {\n" void TestConditionsMultiLineNot()
"\tfile_created one\n" {
"\tdemand\n" BMessage message;
"}\n", message)); CPPUNIT_ASSERT_EQUAL(B_OK, _ParseCondition("if {\n"
CPPUNIT_ASSERT_EQUAL(2, message.CountNames(B_ANY_TYPE)); "\tnot {\n"
"\t\tsafemode\n"
BMessage subMessage; "\t}\n"
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("demand", &subMessage)); "}\n", message));
CPPUNIT_ASSERT(subMessage.IsEmpty());
BMessage subMessage;
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("file_created", CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("not", &subMessage));
&subMessage));
CPPUNIT_ASSERT_EQUAL(BString("one"), BMessage args;
BString(subMessage.GetString("args", 0, "-"))); CPPUNIT_ASSERT_EQUAL(B_OK, subMessage.FindMessage("safemode", &args));
CPPUNIT_ASSERT_EQUAL(1, subMessage.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT(args.IsEmpty());
} }
void TestEventsEmpty()
void {
SettingsParserTest::TestEventsFlat() BMessage message;
{ CPPUNIT_ASSERT_EQUAL(B_OK, _ParseEvent("on {\n"
BMessage message; "}\n", message));
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseEvent("on demand\n", message)); CPPUNIT_ASSERT(message.IsEmpty());
CPPUNIT_ASSERT_EQUAL(1, message.CountNames(B_ANY_TYPE)); }
BMessage args; void TestEventsMultiLine()
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("demand", &args)); {
CPPUNIT_ASSERT(args.IsEmpty()); BMessage message;
} CPPUNIT_ASSERT_EQUAL(B_OK, _ParseEvent("on {\n"
"\tfile_created one\n"
"\tdemand\n"
void "}\n", message));
SettingsParserTest::TestEventsFlatWithArgs() CPPUNIT_ASSERT_EQUAL(2, (int)message.CountNames(B_ANY_TYPE));
{
BMessage message; BMessage subMessage;
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseEvent("on file_created one\n", message)); CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("demand", &subMessage));
CPPUNIT_ASSERT_EQUAL(1, message.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT(subMessage.IsEmpty());
BMessage args; CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("file_created",
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("file_created", &args)); &subMessage));
CPPUNIT_ASSERT_EQUAL(BString("one"), CPPUNIT_ASSERT_EQUAL(BString("one"),
BString(args.GetString("args", 0, "-"))); BString(subMessage.GetString("args", 0, "-")));
CPPUNIT_ASSERT_EQUAL(1, args.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT_EQUAL(1, (int)subMessage.CountNames(B_ANY_TYPE));
} }
void TestEventsFlat()
// #pragma mark - environment {
BMessage message;
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseEvent("on demand\n", message));
void CPPUNIT_ASSERT_EQUAL(1, (int)message.CountNames(B_ANY_TYPE));
SettingsParserTest::TestEnvironmentMultiLine()
{ BMessage args;
BMessage message; CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("demand", &args));
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseName("env", "env {\n" CPPUNIT_ASSERT(args.IsEmpty());
"from_script SetupEnvironment\n" }
"TEST well, yes\n"
"}\n", message)); void TestEventsFlatWithArgs()
CPPUNIT_ASSERT_EQUAL(2, message.CountNames(B_ANY_TYPE)); {
BMessage message;
CPPUNIT_ASSERT_EQUAL(BString("SetupEnvironment"), CPPUNIT_ASSERT_EQUAL(B_OK, _ParseEvent("on file_created one\n", message));
BString(message.GetString("from_script", "-"))); CPPUNIT_ASSERT_EQUAL(1, (int)message.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(1, _ArrayCount(message, "from_script"));
BMessage args;
CPPUNIT_ASSERT_EQUAL(BString("well,"), CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("file_created", &args));
BString(message.GetString("TEST", 0, "-"))); CPPUNIT_ASSERT_EQUAL(BString("one"),
CPPUNIT_ASSERT_EQUAL(BString("yes"), BString(args.GetString("args", 0, "-")));
BString(message.GetString("TEST", 1, "-"))); CPPUNIT_ASSERT_EQUAL(1, (int)args.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(2, _ArrayCount(message, "TEST")); }
}
void TestEnvironmentMultiLine()
{
void BMessage message;
SettingsParserTest::TestEnvironmentFlat() CPPUNIT_ASSERT_EQUAL(B_OK, _ParseName("env", "env {\n"
{ "from_script SetupEnvironment\n"
BMessage message; "TEST well, yes\n"
CPPUNIT_ASSERT_EQUAL(B_OK, _ParseName("env", "env SetupEnvironment\n", "}\n", message));
message)); CPPUNIT_ASSERT_EQUAL(2, (int)message.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(1, message.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(BString("SetupEnvironment"),
CPPUNIT_ASSERT_EQUAL(BString("SetupEnvironment"), BString(message.GetString("from_script", "-")));
BString(message.GetString("from_script", "-"))); CPPUNIT_ASSERT_EQUAL(1, (int)_ArrayCount(message, "from_script"));
CPPUNIT_ASSERT_EQUAL(1, _ArrayCount(message, "from_script"));
} CPPUNIT_ASSERT_EQUAL(BString("well,"),
BString(message.GetString("TEST", 0, "-")));
CPPUNIT_ASSERT_EQUAL(BString("yes"),
// #pragma mark - run BString(message.GetString("TEST", 1, "-")));
CPPUNIT_ASSERT_EQUAL(2, (int)_ArrayCount(message, "TEST"));
}
void
SettingsParserTest::TestRunFlat() void TestEnvironmentFlat()
{ {
SettingsParser parser; BMessage message;
BMessage jobs; CPPUNIT_ASSERT_EQUAL(B_OK, _ParseName("env", "env SetupEnvironment\n",
CPPUNIT_ASSERT_EQUAL(B_OK, parser.Parse("run me", jobs)); message));
CPPUNIT_ASSERT_EQUAL(1, jobs.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT_EQUAL(1, (int)message.CountNames(B_ANY_TYPE));
BMessage message; CPPUNIT_ASSERT_EQUAL(BString("SetupEnvironment"),
CPPUNIT_ASSERT_EQUAL(B_OK, jobs.FindMessage("run", &message)); BString(message.GetString("from_script", "-")));
CPPUNIT_ASSERT_EQUAL(BString("me"), CPPUNIT_ASSERT_EQUAL(1, (int)_ArrayCount(message, "from_script"));
BString(message.GetString("target", "-"))); }
CPPUNIT_ASSERT_EQUAL(1, _ArrayCount(message, "target"));
CPPUNIT_ASSERT_EQUAL(1, message.CountNames(B_ANY_TYPE)); void TestRunFlat()
} {
SettingsParser parser;
BMessage jobs;
void CPPUNIT_ASSERT_EQUAL(B_OK, parser.Parse("run me", jobs));
SettingsParserTest::TestRunMultiLine() CPPUNIT_ASSERT_EQUAL(1, (int)jobs.CountNames(B_ANY_TYPE));
{
SettingsParser parser; BMessage message;
BMessage jobs; CPPUNIT_ASSERT_EQUAL(B_OK, jobs.FindMessage("run", &message));
status_t status = parser.Parse("run {\n" CPPUNIT_ASSERT_EQUAL(BString("me"),
"\tme\n" BString(message.GetString("target", "-")));
"\tyou\n" CPPUNIT_ASSERT_EQUAL(1, (int)_ArrayCount(message, "target"));
"}\n", jobs); CPPUNIT_ASSERT_EQUAL(1, (int)message.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(B_OK, status); }
CPPUNIT_ASSERT_EQUAL(1, jobs.CountNames(B_ANY_TYPE));
void TestRunMultiLine()
BMessage message; {
CPPUNIT_ASSERT_EQUAL(B_OK, jobs.FindMessage("run", &message)); SettingsParser parser;
CPPUNIT_ASSERT_EQUAL(BString("me"), BMessage jobs;
BString(message.GetString("target", 0, "-"))); status_t status = parser.Parse("run {\n"
CPPUNIT_ASSERT_EQUAL(BString("you"), "\tme\n"
BString(message.GetString("target", 1, "-"))); "\tyou\n"
CPPUNIT_ASSERT_EQUAL(2, _ArrayCount(message, "target")); "}\n", jobs);
CPPUNIT_ASSERT_EQUAL(1, message.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT_EQUAL(B_OK, status);
} CPPUNIT_ASSERT_EQUAL(1, (int)jobs.CountNames(B_ANY_TYPE));
BMessage message;
void CPPUNIT_ASSERT_EQUAL(B_OK, jobs.FindMessage("run", &message));
SettingsParserTest::TestRunIfThenElseFlat() CPPUNIT_ASSERT_EQUAL(BString("me"),
{ BString(message.GetString("target", 0, "-")));
SettingsParser parser; CPPUNIT_ASSERT_EQUAL(BString("you"),
BMessage jobs; BString(message.GetString("target", 1, "-")));
status_t status = parser.Parse("run {\n" CPPUNIT_ASSERT_EQUAL(2, (int)_ArrayCount(message, "target"));
"\tif safemode\n" CPPUNIT_ASSERT_EQUAL(1, (int)message.CountNames(B_ANY_TYPE));
"\tthen this\n" }
"\telse that\n"
"}\n", jobs); void TestRunIfThenElseFlat()
CPPUNIT_ASSERT_EQUAL(B_OK, status); {
SettingsParser parser;
BMessage message; BMessage jobs;
CPPUNIT_ASSERT_EQUAL(B_OK, jobs.FindMessage("run", &message)); status_t status = parser.Parse("run {\n"
CPPUNIT_ASSERT_EQUAL(3, message.CountNames(B_ANY_TYPE)); "\tif safemode\n"
"\tthen this\n"
BMessage then; "\telse that\n"
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("then", &then)); "}\n", jobs);
CPPUNIT_ASSERT_EQUAL(BString("this"), CPPUNIT_ASSERT_EQUAL(B_OK, status);
BString(then.GetString("target", "-")));
CPPUNIT_ASSERT_EQUAL(1, _ArrayCount(then, "target")); BMessage message;
CPPUNIT_ASSERT_EQUAL(1, then.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT_EQUAL(B_OK, jobs.FindMessage("run", &message));
CPPUNIT_ASSERT_EQUAL(3, (int)message.CountNames(B_ANY_TYPE));
BMessage otherwise;
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("else", &otherwise)); BMessage then;
CPPUNIT_ASSERT_EQUAL(BString("that"), CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("then", &then));
BString(otherwise.GetString("target", "-"))); CPPUNIT_ASSERT_EQUAL(BString("this"),
CPPUNIT_ASSERT_EQUAL(1, _ArrayCount(otherwise, "target")); BString(then.GetString("target", "-")));
CPPUNIT_ASSERT_EQUAL(1, otherwise.CountNames(B_ANY_TYPE)); CPPUNIT_ASSERT_EQUAL(1, (int)_ArrayCount(then, "target"));
} CPPUNIT_ASSERT_EQUAL(1, (int)then.CountNames(B_ANY_TYPE));
BMessage otherwise;
void CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("else", &otherwise));
SettingsParserTest::TestRunIfThenElseMultiLine() CPPUNIT_ASSERT_EQUAL(BString("that"),
{ BString(otherwise.GetString("target", "-")));
SettingsParser parser; CPPUNIT_ASSERT_EQUAL(1, (int)_ArrayCount(otherwise, "target"));
BMessage jobs; CPPUNIT_ASSERT_EQUAL(1, (int)otherwise.CountNames(B_ANY_TYPE));
status_t status = parser.Parse("run {\n" }
"\tif {\n"
"\t\tread_only\n" void TestRunIfThenElseMultiLine()
"\t}\n" {
"\tthen {\n" SettingsParser parser;
"\t\tthis\n" BMessage jobs;
"\t}\n" status_t status = parser.Parse("run {\n"
"\telse {\n" "\tif {\n"
"\t\tthat\n" "\t\tread_only\n"
"\t}\n" "\t}\n"
"}\n", jobs); "\tthen {\n"
CPPUNIT_ASSERT_EQUAL(B_OK, status); "\t\tthis\n"
"\t}\n"
BMessage message; "\telse {\n"
CPPUNIT_ASSERT_EQUAL(B_OK, jobs.FindMessage("run", &message)); "\t\tthat\n"
CPPUNIT_ASSERT_EQUAL(3, message.CountNames(B_ANY_TYPE)); "\t}\n"
"}\n", jobs);
BMessage then; CPPUNIT_ASSERT_EQUAL(B_OK, status);
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("then", &then));
CPPUNIT_ASSERT_EQUAL(BString("this"), BMessage message;
BString(then.GetString("target", "-"))); CPPUNIT_ASSERT_EQUAL(B_OK, jobs.FindMessage("run", &message));
CPPUNIT_ASSERT_EQUAL(1, _ArrayCount(then, "target")); CPPUNIT_ASSERT_EQUAL(3, (int)message.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(1, then.CountNames(B_ANY_TYPE));
BMessage then;
BMessage otherwise; CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("then", &then));
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("else", &otherwise)); CPPUNIT_ASSERT_EQUAL(BString("this"),
CPPUNIT_ASSERT_EQUAL(BString("that"), BString(then.GetString("target", "-")));
BString(otherwise.GetString("target", "-"))); CPPUNIT_ASSERT_EQUAL(1, (int)_ArrayCount(then, "target"));
CPPUNIT_ASSERT_EQUAL(1, _ArrayCount(otherwise, "target")); CPPUNIT_ASSERT_EQUAL(1, (int)then.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(1, otherwise.CountNames(B_ANY_TYPE));
} BMessage otherwise;
CPPUNIT_ASSERT_EQUAL(B_OK, message.FindMessage("else", &otherwise));
CPPUNIT_ASSERT_EQUAL(BString("that"),
// #pragma mark - BString(otherwise.GetString("target", "-")));
CPPUNIT_ASSERT_EQUAL(1, (int)_ArrayCount(otherwise, "target"));
CPPUNIT_ASSERT_EQUAL(1, (int)otherwise.CountNames(B_ANY_TYPE));
/*static*/ void }
SettingsParserTest::AddTests(BTestSuite& parent) };
{
CppUnit::TestSuite& suite = *new CppUnit::TestSuite("SettingsParserTest");
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(SettingsParserTest, getTestSuiteName());
// Conditions
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestConditionsEmpty",
&SettingsParserTest::TestConditionsEmpty));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestConditionsMultiLine",
&SettingsParserTest::TestConditionsMultiLine));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestConditionsFlat",
&SettingsParserTest::TestConditionsFlat));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestConditionsFlatWithNot",
&SettingsParserTest::TestConditionsFlatWithNot));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestConditionsFlatWithArgs",
&SettingsParserTest::TestConditionsFlatWithArgs));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestConditionsFlatWithNotAndArgs",
&SettingsParserTest::TestConditionsFlatWithNotAndArgs));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestConditionsMultiLineFlatNot",
&SettingsParserTest::TestConditionsMultiLineFlatNot));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestConditionsMultiLineFlatNotWithArgs",
&SettingsParserTest::TestConditionsMultiLineFlatNotWithArgs));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestConditionsMultiLineNot",
&SettingsParserTest::TestConditionsMultiLineNot));
// Events
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestEventsEmpty",
&SettingsParserTest::TestEventsEmpty));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestEventsMultiLine",
&SettingsParserTest::TestEventsMultiLine));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestEventsFlat",
&SettingsParserTest::TestEventsFlat));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestEventsFlatWithArgs",
&SettingsParserTest::TestEventsFlatWithArgs));
// Environment
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestEnvironmentMultiLine",
&SettingsParserTest::TestEnvironmentMultiLine));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestEnvironmentFlat",
&SettingsParserTest::TestEnvironmentFlat));
// Run
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestRunFlat",
&SettingsParserTest::TestRunFlat));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestRunMultiLine",
&SettingsParserTest::TestRunMultiLine));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestRunIfThenElseFlat",
&SettingsParserTest::TestRunIfThenElseFlat));
suite.addTest(new CppUnit::TestCaller<SettingsParserTest>(
"SettingsParserTest::TestRunIfThenElseMultiLine",
&SettingsParserTest::TestRunIfThenElseMultiLine));
parent.addTest("SettingsParserTest", &suite);
}
status_t
SettingsParserTest::_ParseCondition(const char* text, BMessage& message)
{
return _ParseName("if", text, message);
}
status_t
SettingsParserTest::_ParseEvent(const char* text, BMessage& message)
{
return _ParseName("on", text, message);
}
status_t
SettingsParserTest::_ParseName(const char* name, const char* text,
BMessage& message)
{
SettingsParser parser;
BString input("job A {\n");
input << text << "\n}\n";
BMessage jobs;
status_t status = parser.Parse(input, jobs);
if (status != B_OK)
return status;
BMessage job;
status = jobs.FindMessage("job", 0, &job);
if (status != B_OK)
return status;
CPPUNIT_ASSERT_EQUAL(2, job.CountNames(B_ANY_TYPE));
CPPUNIT_ASSERT_EQUAL(BString("A"), BString(job.GetString("name")));
return job.FindMessage(name, &message);
}
int32
SettingsParserTest::_ArrayCount(BMessage& message, const char* name)
{
int32 found;
if (message.GetInfo(name, NULL, &found, NULL) != B_OK)
return 0;
return found;
}
@@ -1,57 +0,0 @@
/*
* Copyright 2015, Axel Dörfler, [email protected].
* Distributed under the terms of the MIT License.
*/
#ifndef SETTINGS_PARSER_TEST_H
#define SETTINGS_PARSER_TEST_H
#include <TestCase.h>
#include <TestSuite.h>
#include <Message.h>
class SettingsParserTest : public CppUnit::TestCase {
public:
SettingsParserTest();
virtual ~SettingsParserTest();
void TestConditionsEmpty();
void TestConditionsMultiLine();
void TestConditionsFlat();
void TestConditionsFlatWithNot();
void TestConditionsFlatWithArgs();
void TestConditionsFlatWithNotAndArgs();
void TestConditionsMultiLineFlatNot();
void TestConditionsMultiLineFlatNotWithArgs();
void TestConditionsMultiLineNot();
void TestEventsEmpty();
void TestEventsMultiLine();
void TestEventsFlat();
void TestEventsFlatWithArgs();
void TestEnvironmentMultiLine();
void TestEnvironmentFlat();
void TestRunFlat();
void TestRunMultiLine();
void TestRunIfThenElseFlat();
void TestRunIfThenElseMultiLine();
static void AddTests(BTestSuite& suite);
private:
status_t _ParseCondition(const char* text,
BMessage& message);
status_t _ParseEvent(const char* text,
BMessage& message);
status_t _ParseName(const char* name, const char* text,
BMessage& message);
int32 _ArrayCount(BMessage& message,
const char* name);
};
#endif // SETTINGS_PARSER_TEST_H
+28 -42
View File
@@ -4,53 +4,39 @@
*/ */
#include "UtilityTest.h"
#include <stdlib.h> #include <stdlib.h>
#include <cppunit/TestCaller.h> #include <TestSuiteAddon.h>
#include <cppunit/TestSuite.h> #include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "Utility.h" #include "Utility.h"
UtilityTest::UtilityTest() class UtilityTest : public CppUnit::TestFixture {
{ CPPUNIT_TEST_SUITE(UtilityTest);
} CPPUNIT_TEST(TestTranslatePath);
CPPUNIT_TEST_SUITE_END();
public:
void TestTranslatePath()
{
CPPUNIT_ASSERT_EQUAL(BString("/boot/home/test"),
Utility::TranslatePath("$HOME/test"));
CPPUNIT_ASSERT_EQUAL(BString("/boot/home/test"),
Utility::TranslatePath("${HOME}/test"));
CPPUNIT_ASSERT_EQUAL(BString("--/boot/home--"),
Utility::TranslatePath("--${HOME}--"));
CPPUNIT_ASSERT_EQUAL(BString("$(HOME)/test"),
Utility::TranslatePath("$(HOME)/test"));
CPPUNIT_ASSERT_EQUAL(BString("/boot/home/test"),
Utility::TranslatePath("~/test"));
CPPUNIT_ASSERT_EQUAL(BString("~baron/test"),
Utility::TranslatePath("~baron/test"));
CPPUNIT_ASSERT_EQUAL(BString("/~/test"),
Utility::TranslatePath("/~/test"));
}
};
UtilityTest::~UtilityTest() CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(UtilityTest, getTestSuiteName());
{
}
void
UtilityTest::TestTranslatePath()
{
CPPUNIT_ASSERT_EQUAL(BString("/boot/home/test"),
Utility::TranslatePath("$HOME/test"));
CPPUNIT_ASSERT_EQUAL(BString("/boot/home/test"),
Utility::TranslatePath("${HOME}/test"));
CPPUNIT_ASSERT_EQUAL(BString("--/boot/home--"),
Utility::TranslatePath("--${HOME}--"));
CPPUNIT_ASSERT_EQUAL(BString("$(HOME)/test"),
Utility::TranslatePath("$(HOME)/test"));
CPPUNIT_ASSERT_EQUAL(BString("/boot/home/test"),
Utility::TranslatePath("~/test"));
CPPUNIT_ASSERT_EQUAL(BString("~baron/test"),
Utility::TranslatePath("~baron/test"));
CPPUNIT_ASSERT_EQUAL(BString("/~/test"),
Utility::TranslatePath("/~/test"));
}
/*static*/ void
UtilityTest::AddTests(BTestSuite& parent)
{
CppUnit::TestSuite& suite = *new CppUnit::TestSuite("UtilityTest");
suite.addTest(new CppUnit::TestCaller<UtilityTest>(
"UtilityTest::TestTranslatePath", &UtilityTest::TestTranslatePath));
parent.addTest("UtilityTest", &suite);
}
-24
View File
@@ -1,24 +0,0 @@
/*
* Copyright 2015, Axel Dörfler, [email protected].
* Distributed under the terms of the MIT License.
*/
#ifndef UTILITY_TEST_H
#define UTILITY_TEST_H
#include <TestCase.h>
#include <TestSuite.h>
class UtilityTest : public CppUnit::TestCase {
public:
UtilityTest();
virtual ~UtilityTest();
void TestTranslatePath();
static void AddTests(BTestSuite& suite);
};
#endif // UTILITY_TEST_H