summaryrefslogtreecommitdiff
path: root/test/core/parser/stack/StackTest.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'test/core/parser/stack/StackTest.cpp')
-rw-r--r--test/core/parser/stack/StackTest.cpp646
1 files changed, 375 insertions, 271 deletions
diff --git a/test/core/parser/stack/StackTest.cpp b/test/core/parser/stack/StackTest.cpp
index a93f14a..a831c32 100644
--- a/test/core/parser/stack/StackTest.cpp
+++ b/test/core/parser/stack/StackTest.cpp
@@ -21,9 +21,11 @@
#include <gtest/gtest.h>
#include <core/frontend/TerminalLogger.hpp>
+#include <core/parser/stack/Callbacks.hpp>
#include <core/parser/stack/Handler.hpp>
#include <core/parser/stack/Stack.hpp>
#include <core/parser/stack/State.hpp>
+#include <core/parser/utils/TokenizedData.hpp>
#include <core/StandaloneEnvironment.hpp>
@@ -37,70 +39,88 @@ static StandaloneEnvironment env(logger);
namespace {
+class Parser : public ParserCallbacks {
+ TokenId registerToken(const std::string &token) override
+ {
+ return Tokens::Empty;
+ }
+
+ void unregisterToken(TokenId id) override
+ {
+ // Do nothing here
+ }
+};
+
+static Parser parser;
+
struct Tracker {
- int startCount;
+ int startCommandCount;
+ int startAnnotationCount;
+ int startTokenCount;
+ int endTokenCount;
int endCount;
int fieldStartCount;
int fieldEndCount;
- int annotationStartCount;
- int annotationEndCount;
int dataCount;
- Variant::mapType startArgs;
- bool fieldStartIsDefault;
- size_t fieldStartIdx;
- Variant annotationStartClassName;
- Variant::mapType annotationStartArgs;
- Variant annotationEndClassName;
- Variant annotationEndElementName;
- Variant dataData;
-
- bool startResult;
- bool fieldStartSetIsDefault;
+ bool startCommandResult;
+ bool startAnnotationResult;
+ bool startTokenResult;
+ Handler::EndTokenResult endTokenResult;
bool fieldStartResult;
- bool annotationStartResult;
- bool annotationEndResult;
bool dataResult;
+ Variant::mapType startCommandArgs;
+ Variant::mapType startAnnotationArgs;
+
+ bool fieldStartReturnValue;
+ size_t fieldStartIdx;
+ bool fieldStartIsDefault;
+ bool fieldStartSetIsDefault;
+
+ Variant dataData;
+
Tracker() { reset(); }
void reset()
{
- startCount = 0;
+ startCommandCount = 0;
+ startAnnotationCount = 0;
+ startTokenCount = 0;
+ endTokenCount = 0;
endCount = 0;
fieldStartCount = 0;
fieldEndCount = 0;
- annotationStartCount = 0;
- annotationEndCount = 0;
dataCount = 0;
- startArgs = Variant::mapType{};
- fieldStartIsDefault = false;
- fieldStartIdx = 0;
- annotationStartClassName = Variant::fromString(std::string{});
- annotationStartArgs = Variant::mapType{};
- annotationEndClassName = Variant::fromString(std::string{});
- annotationEndElementName = Variant::fromString(std::string{});
- dataData = Variant::fromString(std::string{});
-
- startResult = true;
- fieldStartSetIsDefault = false;
+ startCommandResult = true;
+ startAnnotationResult = true;
+ startTokenResult = true;
+ endTokenResult = Handler::EndTokenResult::ENDED_THIS;
fieldStartResult = true;
- annotationStartResult = true;
- annotationEndResult = true;
dataResult = true;
+
+ startCommandArgs = Variant::mapType{};
+ startAnnotationArgs = Variant::mapType{};
+
+ fieldStartIdx = 0;
+ fieldStartIsDefault = false;
+ fieldStartSetIsDefault = false;
+
+ dataData = Variant{};
}
- void expect(int startCount, int endCount, int fieldStartCount,
- int fieldEndCount, int annotationStartCount,
- int annotationEndCount, int dataCount)
+ void expect(int startCommandCount, int endCount, int fieldStartCount,
+ int fieldEndCount, int dataCount, int startAnnotationCount = 0,
+ int startTokenCount = 0, int endTokenCount = 0)
{
- EXPECT_EQ(startCount, this->startCount);
+ EXPECT_EQ(startCommandCount, this->startCommandCount);
+ EXPECT_EQ(startAnnotationCount, this->startAnnotationCount);
+ EXPECT_EQ(startTokenCount, this->startTokenCount);
+ EXPECT_EQ(endTokenCount, this->endTokenCount);
EXPECT_EQ(endCount, this->endCount);
EXPECT_EQ(fieldStartCount, this->fieldStartCount);
EXPECT_EQ(fieldEndCount, this->fieldEndCount);
- EXPECT_EQ(annotationStartCount, this->annotationStartCount);
- EXPECT_EQ(annotationEndCount, this->annotationEndCount);
EXPECT_EQ(dataCount, this->dataCount);
}
};
@@ -112,55 +132,57 @@ private:
TestHandler(const HandlerData &handlerData) : Handler(handlerData) {}
public:
- bool start(Variant::mapType &args) override
+ bool startCommand(Variant::mapType &args) override
{
- tracker.startCount++;
- tracker.startArgs = args;
- if (!tracker.startResult) {
+ tracker.startCommandArgs = args;
+ tracker.startCommandCount++;
+ if (!tracker.startCommandResult) {
logger().error(
- "The TestHandler was told not to allow a field start. So it "
- "doesn't. The TestHandler always obeys its master.");
+ "TestHandler was told not to allow a command start. "
+ "TestHandler always obeys its master.");
}
- return tracker.startResult;
+ return tracker.startCommandResult;
+ }
+
+ bool startAnnotation(Variant::mapType &args,
+ AnnotationType annotationType) override
+ {
+ tracker.startAnnotationArgs = args;
+ tracker.startAnnotationCount++;
+ return tracker.startAnnotationResult;
+ }
+
+ bool startToken(Handle<Node> node) override
+ {
+ tracker.startTokenCount++;
+ return tracker.startTokenResult;
+ }
+
+ EndTokenResult endToken(const Token &token, Handle<Node> node) override
+ {
+ tracker.endTokenCount++;
+ return tracker.endTokenResult;
}
void end() override { tracker.endCount++; }
bool fieldStart(bool &isDefault, size_t fieldIdx) override
{
- tracker.fieldStartCount++;
tracker.fieldStartIsDefault = isDefault;
tracker.fieldStartIdx = fieldIdx;
if (tracker.fieldStartSetIsDefault) {
isDefault = true;
}
+ tracker.fieldStartCount++;
return tracker.fieldStartResult;
}
void fieldEnd() override { tracker.fieldEndCount++; }
- bool annotationStart(const Variant &className,
- Variant::mapType &args) override
- {
- tracker.annotationStartCount++;
- tracker.annotationStartClassName = className;
- tracker.annotationStartArgs = args;
- return tracker.annotationStartResult;
- }
-
- bool annotationEnd(const Variant &className,
- const Variant &elementName) override
- {
- tracker.annotationEndCount++;
- tracker.annotationEndClassName = className;
- tracker.annotationEndElementName = elementName;
- return tracker.annotationEndResult;
- }
-
- bool data(Variant &data) override
+ bool data() override
{
+ tracker.dataData = readData();
tracker.dataCount++;
- tracker.dataData = data;
return tracker.dataResult;
}
@@ -204,75 +226,137 @@ TEST(Stack, basicTest)
tracker.reset();
logger.reset();
{
- Stack s{env.context, States::TestHandlers};
+ Stack s{parser, env.context, States::TestHandlers};
EXPECT_EQ("", s.currentCommandName());
EXPECT_EQ(&States::None, &s.currentState());
- s.command("document", {});
+ s.commandStart("document", {});
s.fieldStart(true);
s.data("test1");
EXPECT_EQ("document", s.currentCommandName());
EXPECT_EQ(&States::Document, &s.currentState());
- tracker.expect(1, 0, 1, 0, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 0, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
- s.command("body", {});
+ s.commandStart("body", {});
s.fieldStart(true);
s.data("test2");
EXPECT_EQ("body", s.currentCommandName());
EXPECT_EQ(&States::Body, &s.currentState());
- tracker.expect(2, 0, 2, 0, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(2, 0, 2, 0, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
- s.command("inner", {});
+ s.commandStart("inner", {});
s.fieldStart(true);
EXPECT_EQ("inner", s.currentCommandName());
EXPECT_EQ(&States::BodyChildren, &s.currentState());
s.fieldEnd();
- tracker.expect(3, 0, 3, 1, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(3, 0, 3, 1, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldEnd();
EXPECT_EQ("body", s.currentCommandName());
EXPECT_EQ(&States::Body, &s.currentState());
- tracker.expect(3, 1, 3, 2, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(3, 1, 3, 2, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
- s.command("body", {});
+ s.commandStart("body", {});
EXPECT_EQ("body", s.currentCommandName());
EXPECT_EQ(&States::Body, &s.currentState());
- tracker.expect(4, 2, 3, 2, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(4, 2, 3, 2, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldStart(true);
s.data("test3");
EXPECT_EQ("body", s.currentCommandName());
EXPECT_EQ(&States::Body, &s.currentState());
s.fieldEnd();
- tracker.expect(4, 2, 4, 3, 0, 0, 3); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(4, 2, 4, 3, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
EXPECT_EQ("body", s.currentCommandName());
EXPECT_EQ(&States::Body, &s.currentState());
s.fieldEnd();
- tracker.expect(4, 3, 4, 4, 0, 0, 3); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(4, 3, 4, 4, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
EXPECT_EQ("document", s.currentCommandName());
EXPECT_EQ(&States::Document, &s.currentState());
}
- tracker.expect(4, 4, 4, 4, 0, 0, 3); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(4, 4, 4, 4, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
+ ASSERT_FALSE(logger.hasError());
+}
+
+TEST(Stack, basicTestRangeCommands)
+{
+ tracker.reset();
+ logger.reset();
+ {
+ Stack s{parser, env.context, States::TestHandlers};
+
+ EXPECT_EQ("", s.currentCommandName());
+ EXPECT_EQ(&States::None, &s.currentState());
+
+ s.commandStart("document", {}, true);
+ EXPECT_EQ("document", s.currentCommandName());
+ EXPECT_EQ(&States::Document, &s.currentState());
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+
+ s.data("test1");
+ tracker.expect(1, 0, 1, 0, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
+
+ s.commandStart("body", {}, true);
+ tracker.expect(2, 0, 1, 0, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.data("test2");
+ tracker.expect(2, 0, 2, 0, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+ EXPECT_EQ("body", s.currentCommandName());
+ EXPECT_EQ(&States::Body, &s.currentState());
+
+ s.commandStart("inner", {}, true);
+ tracker.expect(3, 0, 2, 0, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+ EXPECT_EQ("inner", s.currentCommandName());
+ EXPECT_EQ(&States::BodyChildren, &s.currentState());
+ s.rangeEnd();
+ tracker.expect(3, 1, 3, 1, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+ EXPECT_EQ("body", s.currentCommandName());
+ EXPECT_EQ(&States::Body, &s.currentState());
+ s.rangeEnd();
+ tracker.expect(3, 2, 3, 2, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+
+ s.commandStart("body", {}, true);
+ EXPECT_EQ("body", s.currentCommandName());
+ EXPECT_EQ(&States::Body, &s.currentState());
+ tracker.expect(4, 2, 3, 2, 2); // scc, ec, fsc, fse, dc, sac, stc, etc
+ s.fieldStart(true);
+ tracker.expect(4, 2, 4, 2, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.data("test3");
+ tracker.expect(4, 2, 4, 2, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
+ EXPECT_EQ("body", s.currentCommandName());
+ EXPECT_EQ(&States::Body, &s.currentState());
+ s.fieldEnd();
+ tracker.expect(4, 2, 4, 3, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
+ EXPECT_EQ("body", s.currentCommandName());
+ EXPECT_EQ(&States::Body, &s.currentState());
+ s.rangeEnd();
+ tracker.expect(4, 3, 4, 3, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
+
+ EXPECT_EQ("document", s.currentCommandName());
+ EXPECT_EQ(&States::Document, &s.currentState());
+ s.rangeEnd();
+ tracker.expect(4, 4, 4, 4, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
+ }
+ tracker.expect(4, 4, 4, 4, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_FALSE(logger.hasError());
}
TEST(Stack, errorInvalidCommands)
{
- Stack s{env.context, States::TestHandlers};
+ Stack s{parser, env.context, States::TestHandlers};
tracker.reset();
- EXPECT_THROW(s.command("body", {}), LoggableException);
- s.command("document", {});
+ EXPECT_THROW(s.commandStart("body", {}), LoggableException);
+ s.commandStart("document", {});
s.fieldStart(true);
- EXPECT_THROW(s.command("document", {}), LoggableException);
- s.command("empty", {});
+ EXPECT_THROW(s.commandStart("document", {}), LoggableException);
+ s.commandStart("empty", {});
s.fieldStart(true);
- EXPECT_THROW(s.command("body", {}), LoggableException);
- s.command("special", {});
+ EXPECT_THROW(s.commandStart("body", {}), LoggableException);
+ s.commandStart("special", {});
s.fieldStart(true);
s.fieldEnd();
s.fieldEnd();
@@ -288,23 +372,23 @@ TEST(Stack, errorInvalidCommands)
TEST(Stack, validation)
{
- Stack s{env.context, States::TestHandlers};
+ Stack s{parser, env.context, States::TestHandlers};
tracker.reset();
logger.reset();
- s.command("arguments", {});
+ s.commandStart("arguments", {});
EXPECT_TRUE(logger.hasError());
s.fieldStart(true);
s.fieldEnd();
logger.reset();
- s.command("arguments", {{"a", 5}});
+ s.commandStart("arguments", {{"a", 5}}, false);
EXPECT_TRUE(logger.hasError());
s.fieldStart(true);
s.fieldEnd();
logger.reset();
- s.command("arguments", {{"a", 5}, {"b", "test"}});
+ s.commandStart("arguments", {{"a", 5}, {"b", "test"}}, false);
EXPECT_FALSE(logger.hasError());
s.fieldStart(true);
s.fieldEnd();
@@ -315,33 +399,33 @@ TEST(Stack, invalidCommandName)
tracker.reset();
logger.reset();
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldStart(true);
s.fieldEnd();
- tracker.expect(1, 0, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
- s.command("a_", {});
- tracker.expect(2, 1, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("a_", {});
+ tracker.expect(2, 1, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldStart(true);
s.fieldEnd();
- tracker.expect(2, 1, 2, 2, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(2, 1, 2, 2, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
- s.command("a_:b", {});
- tracker.expect(3, 2, 2, 2, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("a_:b", {});
+ tracker.expect(3, 2, 2, 2, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldStart(true);
s.fieldEnd();
- tracker.expect(3, 2, 3, 3, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(3, 2, 3, 3, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
- ASSERT_THROW(s.command("_a", {}), LoggableException);
- tracker.expect(3, 3, 3, 3, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ ASSERT_THROW(s.commandStart("_a", {}), LoggableException);
+ tracker.expect(3, 3, 3, 3, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
- ASSERT_THROW(s.command("a:", {}), LoggableException);
- tracker.expect(3, 3, 3, 3, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ ASSERT_THROW(s.commandStart("a:", {}), LoggableException);
+ tracker.expect(3, 3, 3, 3, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
- ASSERT_THROW(s.command("a:_b", {}), LoggableException);
- tracker.expect(3, 3, 3, 3, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ ASSERT_THROW(s.commandStart("a:_b", {}), LoggableException);
+ tracker.expect(3, 3, 3, 3, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
TEST(Stack, multipleFields)
@@ -349,50 +433,50 @@ TEST(Stack, multipleFields)
tracker.reset();
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
+ Stack s{parser, env.context, States::AnyHandlers};
- s.command("a", {{"a", false}});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("a", {{"a", false}}, false);
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
EXPECT_EQ("a", s.currentCommandName());
- EXPECT_EQ(Variant::mapType({{"a", false}}), tracker.startArgs);
+ EXPECT_EQ(Variant::mapType({{"a", false}}), tracker.startCommandArgs);
s.fieldStart(false);
- tracker.expect(1, 0, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
EXPECT_FALSE(tracker.fieldStartIsDefault);
EXPECT_EQ(0U, tracker.fieldStartIdx);
s.data("test");
- tracker.expect(1, 0, 1, 0, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
- EXPECT_EQ("test", tracker.dataData);
+ tracker.expect(1, 0, 1, 0, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
+ EXPECT_EQ("test", tracker.dataData.asString());
s.fieldEnd();
- tracker.expect(1, 0, 1, 1, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 1, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldStart(false);
- tracker.expect(1, 0, 2, 1, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 2, 1, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
EXPECT_FALSE(tracker.fieldStartIsDefault);
EXPECT_EQ(1U, tracker.fieldStartIdx);
s.data("test2");
- tracker.expect(1, 0, 2, 1, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
- EXPECT_EQ("test2", tracker.dataData);
+ tracker.expect(1, 0, 2, 1, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+ EXPECT_EQ("test2", tracker.dataData.asString());
s.fieldEnd();
- tracker.expect(1, 0, 2, 2, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 2, 2, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldStart(true);
- tracker.expect(1, 0, 3, 2, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 3, 2, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
EXPECT_TRUE(tracker.fieldStartIsDefault);
EXPECT_EQ(2U, tracker.fieldStartIdx);
s.data("test3");
- tracker.expect(1, 0, 3, 2, 0, 0, 3); // sc, ec, fsc, fse, asc, aec, dc
- EXPECT_EQ("test3", tracker.dataData);
+ tracker.expect(1, 0, 3, 2, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
+ EXPECT_EQ("test3", tracker.dataData.asString());
s.fieldEnd();
- tracker.expect(1, 0, 3, 3, 0, 0, 3); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 3, 3, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
}
- tracker.expect(1, 1, 3, 3, 0, 0, 3); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 1, 3, 3, 3); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_FALSE(logger.hasError());
}
@@ -401,15 +485,15 @@ TEST(Stack, implicitDefaultFieldOnNewCommand)
tracker.reset();
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
+ Stack s{parser, env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
- s.command("b", {});
- tracker.expect(2, 0, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("b", {});
+ tracker.expect(2, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
- tracker.expect(2, 2, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(2, 2, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_FALSE(logger.hasError());
}
@@ -418,21 +502,21 @@ TEST(Stack, implicitDefaultFieldOnNewCommandWithExplicitDefaultField)
tracker.reset();
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
+ Stack s{parser, env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_EQ("a", s.currentCommandName());
- s.command("b", {});
- tracker.expect(2, 0, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("b", {});
+ tracker.expect(2, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_EQ("b", s.currentCommandName());
s.fieldStart(true);
s.fieldEnd();
- tracker.expect(2, 0, 2, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(2, 0, 2, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_EQ("b", s.currentCommandName());
}
- tracker.expect(2, 2, 2, 2, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(2, 2, 2, 2, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_FALSE(logger.hasError());
}
@@ -441,18 +525,18 @@ TEST(Stack, noImplicitDefaultFieldOnIncompatibleCommand)
tracker.reset();
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
+ Stack s{parser, env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_EQ("a", s.currentCommandName());
tracker.fieldStartResult = false;
- s.command("b", {});
- tracker.expect(2, 1, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("b", {});
+ tracker.expect(2, 1, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_EQ("b", s.currentCommandName());
}
- tracker.expect(2, 2, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(2, 2, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_FALSE(logger.hasError());
}
@@ -461,23 +545,23 @@ TEST(Stack, noImplicitDefaultFieldIfDefaultFieldGiven)
tracker.reset();
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
+ Stack s{parser, env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_EQ("a", s.currentCommandName());
s.fieldStart(true);
- tracker.expect(1, 0, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_EQ("a", s.currentCommandName());
s.fieldEnd();
- tracker.expect(1, 0, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_EQ("a", s.currentCommandName());
- s.command("b", {});
- tracker.expect(2, 1, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("b", {});
+ tracker.expect(2, 1, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_EQ("b", s.currentCommandName());
}
- tracker.expect(2, 2, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(2, 2, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_FALSE(logger.hasError());
}
@@ -486,18 +570,18 @@ TEST(Stack, noEndIfStartFails)
tracker.reset();
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
+ Stack s{parser, env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_EQ("a", s.currentCommandName());
- tracker.startResult = false;
- s.command("b", {});
- tracker.expect(3, 1, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
- ASSERT_EQ("b", s.currentCommandName());
+ tracker.startCommandResult = false;
+ s.commandStart("b", {});
+ tracker.expect(3, 1, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+ EXPECT_EQ(&States::None, &s.currentState());
}
- tracker.expect(3, 1, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(3, 1, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_TRUE(logger.hasError());
}
@@ -506,15 +590,15 @@ TEST(Stack, implicitDefaultFieldOnData)
tracker.reset();
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
+ Stack s{parser, env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
s.data("test");
- tracker.expect(1, 0, 1, 0, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 0, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
}
- tracker.expect(1, 1, 1, 1, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 1, 1, 1, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_FALSE(logger.hasError());
}
@@ -524,11 +608,11 @@ TEST(Stack, autoFieldEnd)
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
- tracker.expect(1, 1, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 1, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_FALSE(logger.hasError());
}
@@ -538,17 +622,17 @@ TEST(Stack, autoImplicitFieldEnd)
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
- s.command("b", {});
- s.command("c", {});
- s.command("d", {});
- s.command("e", {});
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
+ s.commandStart("b", {});
+ s.commandStart("c", {});
+ s.commandStart("d", {});
+ s.commandStart("e", {});
s.fieldStart(true);
s.fieldEnd();
- tracker.expect(5, 0, 5, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(5, 0, 5, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
- tracker.expect(5, 5, 5, 5, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(5, 5, 5, 5, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_FALSE(logger.hasError());
}
@@ -558,14 +642,14 @@ TEST(Stack, invalidDefaultField)
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
tracker.fieldStartResult = false;
s.fieldStart(true);
s.fieldEnd();
- tracker.expect(1, 0, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
- tracker.expect(1, 1, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 1, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
ASSERT_FALSE(logger.hasError());
}
@@ -575,17 +659,17 @@ TEST(Stack, errorInvalidDefaultFieldData)
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
tracker.fieldStartResult = false;
s.fieldStart(true);
ASSERT_FALSE(logger.hasError());
s.data("test");
ASSERT_TRUE(logger.hasError());
s.fieldEnd();
- tracker.expect(1, 0, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
- tracker.expect(1, 1, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 1, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
TEST(Stack, errorInvalidFieldData)
@@ -594,17 +678,17 @@ TEST(Stack, errorInvalidFieldData)
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
tracker.fieldStartResult = false;
ASSERT_FALSE(logger.hasError());
s.fieldStart(false);
ASSERT_TRUE(logger.hasError());
s.data("test");
s.fieldEnd();
- tracker.expect(1, 0, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
- tracker.expect(1, 1, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 1, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
TEST(Stack, errorFieldStartNoCommand)
@@ -612,10 +696,10 @@ TEST(Stack, errorFieldStartNoCommand)
tracker.reset();
logger.reset();
- Stack s{env.context, States::AnyHandlers};
+ Stack s{parser, env.context, States::AnyHandlers};
ASSERT_THROW(s.fieldStart(false), LoggableException);
ASSERT_THROW(s.fieldStart(true), LoggableException);
- tracker.expect(0, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(0, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
TEST(Stack, errorMultipleFieldStarts)
@@ -624,20 +708,20 @@ TEST(Stack, errorMultipleFieldStarts)
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldStart(false);
ASSERT_FALSE(logger.hasError());
s.fieldStart(false);
ASSERT_TRUE(logger.hasError());
- tracker.expect(1, 0, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldEnd();
- tracker.expect(1, 0, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
- tracker.expect(1, 1, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 1, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
TEST(Stack, errorMultipleFieldEnds)
@@ -646,102 +730,122 @@ TEST(Stack, errorMultipleFieldEnds)
logger.reset();
{
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldStart(false);
s.fieldEnd();
ASSERT_FALSE(logger.hasError());
- tracker.expect(1, 0, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 0, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
s.fieldEnd();
ASSERT_TRUE(logger.hasError());
- tracker.expect(1, 1, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 1, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
- tracker.expect(1, 1, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.expect(1, 1, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
TEST(Stack, errorOpenField)
{
- tracker.reset();
- logger.reset();
-
- {
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
-
- s.fieldStart(false);
- ASSERT_FALSE(logger.hasError());
- }
- ASSERT_TRUE(logger.hasError());
- tracker.expect(1, 1, 1, 1, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.reset();
+ logger.reset();
+
+ {
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+
+ s.fieldStart(false);
+ ASSERT_FALSE(logger.hasError());
+ }
+ ASSERT_TRUE(logger.hasError());
+ tracker.expect(1, 1, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
}
TEST(Stack, fieldEndWhenImplicitDefaultFieldOpen)
{
- tracker.reset();
- logger.reset();
-
- {
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
- s.fieldStart(true);
- s.command("b", {});
- s.data("test");
- s.fieldEnd();
- tracker.expect(2, 1, 2, 2, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
- }
- tracker.expect(2, 2, 2, 2, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
- ASSERT_FALSE(logger.hasError());
+ tracker.reset();
+ logger.reset();
+
+ {
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
+ s.fieldStart(true);
+ s.commandStart("b", {});
+ s.data("test");
+ s.fieldEnd();
+ tracker.expect(2, 1, 2, 2, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
+ }
+ tracker.expect(2, 2, 2, 2, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
+ ASSERT_FALSE(logger.hasError());
}
TEST(Stack, fieldAfterDefaultField)
{
- tracker.reset();
- logger.reset();
-
- {
- Stack s{env.context, States::AnyHandlers};
- s.command("a", {});
- tracker.expect(1, 0, 0, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
- s.fieldStart(true);
- tracker.expect(1, 0, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
-
- s.command("b", {});
- tracker.expect(2, 0, 1, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
-
- s.fieldStart(false);
- tracker.expect(2, 0, 2, 0, 0, 0, 0); // sc, ec, fsc, fse, asc, aec, dc
- s.data("f1");
- tracker.expect(2, 0, 2, 0, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
- s.fieldEnd();
- tracker.expect(2, 0, 2, 1, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
- tracker.fieldStartSetIsDefault = true;
-
- s.fieldStart(false);
- tracker.fieldStartSetIsDefault = false;
- tracker.expect(2, 0, 3, 1, 0, 0, 1); // sc, ec, fsc, fse, asc, aec, dc
- s.data("f2");
- tracker.expect(2, 0, 3, 1, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
- s.fieldEnd();
- tracker.expect(2, 0, 3, 2, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
+ tracker.reset();
+ logger.reset();
+
+ {
+ Stack s{parser, env.context, States::AnyHandlers};
+ s.commandStart("a", {});
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.fieldStart(true);
+ tracker.expect(1, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+
+ s.commandStart("b", {});
+ tracker.expect(2, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+
+ s.fieldStart(false);
+ tracker.expect(2, 0, 2, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.data("f1");
+ tracker.expect(2, 0, 2, 0, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.fieldEnd();
+ tracker.expect(2, 0, 2, 1, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
+ tracker.fieldStartSetIsDefault = true;
+
+ s.fieldStart(false);
+ tracker.fieldStartSetIsDefault = false;
+ tracker.expect(2, 0, 3, 1, 1); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.data("f2");
+ tracker.expect(2, 0, 3, 1, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.fieldEnd();
+ tracker.expect(2, 0, 3, 2, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+
+ ASSERT_FALSE(logger.hasError());
+ s.fieldStart(false);
+ ASSERT_TRUE(logger.hasError());
+ logger.reset();
+ tracker.expect(2, 0, 3, 2, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.data("f3");
+ tracker.expect(2, 0, 3, 2, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.fieldEnd();
+ tracker.expect(2, 0, 3, 2, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+
+ s.fieldEnd();
+ tracker.expect(2, 1, 3, 3, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+ }
+ tracker.expect(2, 2, 3, 3, 2); // scc, ec, fsc, fec, dc, sac, stc, etc
+ ASSERT_FALSE(logger.hasError());
+}
- ASSERT_FALSE(logger.hasError());
- s.fieldStart(false);
- ASSERT_TRUE(logger.hasError());
- logger.reset();
- tracker.expect(2, 0, 3, 2, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
- s.data("f3");
- tracker.expect(2, 0, 3, 2, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
- s.fieldEnd();
- tracker.expect(2, 0, 3, 2, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
+TEST(Stack, rangeCommandUnranged)
+{
+ tracker.reset();
+ logger.reset();
+
+ {
+ Stack s{parser, env.context, States::AnyHandlers};
+ tracker.expect(0, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.commandStart("a", {}, true);
+ tracker.expect(1, 0, 0, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.commandStart("b", {});
+ tracker.expect(2, 0, 1, 0, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+ s.rangeEnd();
+ tracker.expect(2, 2, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+ }
+ tracker.expect(2, 2, 1, 1, 0); // scc, ec, fsc, fec, dc, sac, stc, etc
+ ASSERT_FALSE(logger.hasError());
+}
- s.fieldEnd();
- tracker.expect(2, 1, 3, 3, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
- }
- tracker.expect(2, 2, 3, 3, 0, 0, 2); // sc, ec, fsc, fse, asc, aec, dc
- ASSERT_FALSE(logger.hasError());
}
}
-} \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-30 18:37:12 +0000