Adapted all unit tests, renamed COMMAND_END event to RANGE_END event to match ranged annotations

3 files changed, 299 insertions, 178 deletions

diff --git a/src/formats/osml/OsmlStreamParser.cpp b/src/formats/osml/OsmlStreamParser.cpp
index 7e01a3c..e467dc5 100644
--- a/src/formats/osml/OsmlStreamParser.cpp
+++ b/src/formats/osml/OsmlStreamParser.cpp
@@ -127,7 +127,7 @@ private:
 	/**
 	 * Set to true if this is a command with clear begin and end.
 	 */
-	bool hasRange;
+	bool hasRange: 1;
 
 public:
 	/**
@@ -259,7 +259,7 @@ public:
 	 */
 	enum class State : uint8_t {
 		COMMAND_START = 0,
-		COMMAND_END = 1,
+		RANGE_END = 1,
 		FIELD_START = 2,
 		FIELD_END = 3,
 		ANNOTATION_START = 4,
@@ -328,7 +328,7 @@ private:
 	 *
 	 * @return an internal State specifying whether an error occured (return
 	 * values State::REOVERABLE_ERROR or State::IRRECOVERABLE_ERROR) or a
-	 * command was actually ended (return value State::COMMAND_END).
+	 * command was actually ended (return value State::RANGE_END).
 	 */
 	State parseEndCommand();
 
@@ -569,7 +569,7 @@ OsmlStreamParserImpl::State OsmlStreamParserImpl::parseEndCommand()
 	// End the current command
 	location = name.getLocation();
 	commands.pop();
-	return State::COMMAND_END;
+	return State::RANGE_END;
 }
 
 Variant OsmlStreamParserImpl::parseCommandArguments(Variant commandArgName)
@@ -808,14 +808,15 @@ OsmlStreamParserImpl::State OsmlStreamParserImpl::parse()
 
 			// If this was an annotation start token, add the parsed < to the
 			// output
+			SourceOffset charStart = token.location.getStart();
+			SourceOffset charEnd = reader.getPeekOffset();
 			if (type == OsmlTokens.AnnotationStart) {
-				data.append('<', token.location.getStart(),
-				            token.location.getStart() + 1);
+				data.append('<', charStart, charStart + 1);
+				charStart = charStart + 1;
 			}
 
 			// Append the character to the output data, mark it as protected
-			data.append(c, token.location.getStart(), reader.getPeekOffset(),
-			            true);
+			data.append(c, charStart, charEnd, true);
 			reader.consumePeek();
 			continue;
 		} else if (type == Tokens::Data) {
@@ -880,11 +881,12 @@ OsmlStreamParserImpl::State OsmlStreamParserImpl::parse()
 
 	// Make sure all open commands and fields have been ended at the end of the
 	// stream
-	while (commands.size() > 1) {
+	while (true) {
+		bool topLevelCommand = commands.size() == 1U;
 		if (cmd().inField()) {
 			// If the stream ended with an open range field, issue information
 			// about the range field
-			if (cmd().inRangeField()) {
+			if (cmd().inRangeField() && !topLevelCommand) {
 				// Inform about the still open command itself
 				logger.error("Reached end of stream, but command \"" +
 				                 getCommandName().asString() +
@@ -901,7 +903,11 @@ OsmlStreamParserImpl::State OsmlStreamParserImpl::parse()
 				}
 			}
 		}
-		commands.pop();
+		if (!topLevelCommand) {
+			commands.pop();
+		} else {
+			break;
+		}
 	}
 
 	location = SourceLocation{reader.getSourceId(), reader.getOffset()};
diff --git a/src/formats/osml/OsmlStreamParser.hpp b/src/formats/osml/OsmlStreamParser.hpp
index 1fee90b..10d5296 100644
--- a/src/formats/osml/OsmlStreamParser.hpp
+++ b/src/formats/osml/OsmlStreamParser.hpp
@@ -69,11 +69,11 @@ public:
 		COMMAND_START = 0,
 
 		/**
-	     * State returned if a range command has just ended. This state is not
-	     * returned for non-range commands (as the actual end of a command is
-	     * context dependant).
+	     * State returned if a range command or range annotation has just ended.
+	     * This state is not returned for non-range commands (as the actual end
+	     * of a command is context dependent).
 	     */
-		COMMAND_END = 1,
+		RANGE_END = 1,
 
 		/**
 	     * State returned if a new field started. The reader assures that the
@@ -185,7 +185,8 @@ public:
 
 	/**
 	 * Returns true if the currently started command is a range command, only
-	 * valid if State::COMMAND_START was returned by the "parse" function.
+	 * valid if State::COMMAND_START or State::ANNOTATION_START was returned by
+	 * the "parse" function.
 	 *
 	 * @return true if the command is started is a range command, false
 	 * otherwise.
diff --git a/test/formats/osml/OsmlStreamParserTest.cpp b/test/formats/osml/OsmlStreamParserTest.cpp
index 8b64e51..3e7f4c1 100644
--- a/test/formats/osml/OsmlStreamParserTest.cpp
+++ b/test/formats/osml/OsmlStreamParserTest.cpp
@@ -70,11 +70,11 @@ static void assertCommand(OsmlStreamParser &parser,
 	assertCommandStart(parser, name, false, Variant::mapType{}, start, end);
 }
 
-static void assertCommandEnd(OsmlStreamParser &parser,
+static void assertRangeEnd(OsmlStreamParser &parser,
                              SourceOffset start = InvalidSourceOffset,
                              SourceOffset end = InvalidSourceOffset)
 {
-	ASSERT_EQ(OsmlStreamParser::State::COMMAND_END, parser.parse());
+	ASSERT_EQ(OsmlStreamParser::State::RANGE_END, parser.parse());
 	if (start != InvalidSourceOffset) {
 		EXPECT_EQ(start, parser.getLocation().getStart());
 	}
@@ -510,6 +510,61 @@ TEST(OsmlStreamParser, fields)
 	assertEnd(parser, 14, 14);
 }
 
+TEST(OsmlStreamParser, fieldsWithoutCommand)
+{
+	const char *testString = "{a}{b}{c}";
+	//                        012345678
+	CharReader charReader(testString);
+	OsmlStreamParser parser(charReader, logger);
+
+	assertFieldStart(parser, false, 0, 1);
+	assertTextData(parser, "a", 1, 2, 1, 2, WhitespaceMode::PRESERVE);
+	assertFieldEnd(parser, 2, 3);
+
+	assertFieldStart(parser, false, 3, 4);
+	assertTextData(parser, "b", 4, 5, 4, 5, WhitespaceMode::PRESERVE);
+	assertFieldEnd(parser, 5, 6);
+
+	assertFieldStart(parser, false, 6, 7);
+	assertTextData(parser, "c", 7, 8, 7, 8, WhitespaceMode::PRESERVE);
+	assertFieldEnd(parser, 8, 9);
+	assertEnd(parser, 9, 9);
+}
+
+TEST(OsmlStreamParser, nestedField)
+{
+	const char *testString = "{{a{b}}}";
+	//                        01234567
+	CharReader charReader(testString);
+	OsmlStreamParser parser(charReader, logger);
+
+	assertFieldStart(parser, false, 0, 1);
+	assertFieldStart(parser, false, 1, 2);
+	assertTextData(parser, "a", 2, 3, 2, 3, WhitespaceMode::PRESERVE);
+	assertFieldStart(parser, false, 3, 4);
+	assertTextData(parser, "b", 4, 5, 4, 5, WhitespaceMode::PRESERVE);
+	assertFieldEnd(parser, 5, 6);
+	assertFieldEnd(parser, 6, 7);
+	assertFieldEnd(parser, 7, 8);
+	assertEnd(parser, 8, 8);
+}
+
+TEST(OsmlStreamParser, errorUnbalancedField)
+{
+	const char *testString = "{a";
+	//                        01
+	CharReader charReader(testString);
+	OsmlStreamParser parser(charReader, logger);
+
+	logger.reset();
+
+	assertFieldStart(parser, false, 0, 1);
+	assertTextData(parser, "a", 1, 2, 1, 2, WhitespaceMode::PRESERVE);
+	ASSERT_FALSE(logger.hasError());
+	assertEnd(parser, 2, 2);
+	ASSERT_TRUE(logger.hasError());
+}
+
 TEST(OsmlStreamParser, dataOutsideField)
 {
 	const char *testString = "\\test{a}{b} c";
@@ -720,7 +775,7 @@ TEST(OsmlStreamParser, beginEnd)
     OsmlStreamParser parser(charReader, logger);
 
     assertCommandStart(parser, "book", true, Variant::mapType{}, 7, 11);
-    assertCommandEnd(parser, 17, 21);
+    assertRangeEnd(parser, 17, 21);
     assertEnd(parser, 22, 22);
 }
 
@@ -734,7 +789,7 @@ TEST(OsmlStreamParser, beginEndWithName)
     OsmlStreamParser parser(charReader, logger);
 
     assertCommandStart(parser, "book", true, {{"name", "a"}}, 7, 11);
-    assertCommandEnd(parser, 19, 23);
+    assertRangeEnd(parser, 19, 23);
     assertEnd(parser, 24, 24);
 }
 
@@ -749,7 +804,7 @@ TEST(OsmlStreamParser, beginEndWithNameAndArgs)
 
     assertCommandStart(parser, "book", true,
                   {{"name", "a"}, {"a", 1}, {"b", 2}, {"c", "test"}}, 7, 11);
-    assertCommandEnd(parser, 37, 41);
+    assertRangeEnd(parser, 37, 41);
     assertEnd(parser, 42, 42);
 }
 
@@ -775,7 +830,7 @@ TEST(OsmlStreamParser, beginEndWithNameAndArgsMultipleFields)
     assertFieldStart(parser, false, 49, 50);
     assertFieldEnd(parser, 50, 51);
     assertFieldEnd(parser, 51, 52);
-    assertCommandEnd(parser, 57, 61);
+    assertRangeEnd(parser, 57, 61);
     assertEnd(parser, 62, 62);
 }
 
@@ -790,10 +845,10 @@ TEST(OsmlStreamParser, beginEndWithData)
 
     assertCommandStart(parser, "book", true, Variant::mapType{}, 7, 11);
     assertData(parser, "a", 12, 13);
-    assertCommandEnd(parser, 18, 22);
+    assertRangeEnd(parser, 18, 22);
     assertEnd(parser, 23, 23);
 }
-/*
+
 TEST(OsmlStreamParser, beginEndNested)
 {
     const char *testString =
@@ -802,29 +857,32 @@ TEST(OsmlStreamParser, beginEndNested)
     //    0         1          2         3           4          5
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
-
-    assertCommand(reader, "a", 7, 8);
-    assertFieldStart(reader, false, 9, 10);
-    assertData(reader, "b", 10, 11);
-    assertFieldEnd(reader, 11, 12);
-    assertFieldStart(reader, true, 13, 14);
-    assertData(reader, "c", 13, 14);
-    assertCommand(reader, "d", 22, 23);
-    assertFieldStart(reader, false, 24, 25);
-    assertData(reader, "e", 25, 26);
-    assertFieldEnd(reader, 26, 27);
-    assertFieldStart(reader, false, 27, 28);
-    assertData(reader, "f", 28, 29);
-    assertFieldEnd(reader, 29, 30);
-    assertFieldStart(reader, true, 31, 32);
-    assertCommand(reader, "g", 31, 33);
-    assertFieldStart(reader, false, 33, 34);
-    assertData(reader, "h", 34, 35);
-    assertFieldEnd(reader, 35, 36);
-    assertFieldEnd(reader, 42, 43);
-    assertFieldEnd(reader, 49, 50);
-    assertEnd(reader, 51, 51);
+    OsmlStreamParser parser(charReader, logger);
+
+    assertCommandStart(parser, "a", true, Variant::mapType{}, 7, 8);
+    assertFieldStart(parser, false, 9, 10);
+    assertData(parser, "b", 10, 11);
+    assertFieldEnd(parser, 11, 12);
+
+    assertData(parser, "c", 13, 14);
+
+    assertCommandStart(parser, "d", true, Variant::mapType{}, 22, 23);
+    assertFieldStart(parser, false, 24, 25);
+    assertData(parser, "e", 25, 26);
+    assertFieldEnd(parser, 26, 27);
+    assertFieldStart(parser, false, 27, 28);
+    assertData(parser, "f", 28, 29);
+    assertFieldEnd(parser, 29, 30);
+
+    assertEmptyData(parser);
+    assertCommand(parser, "g", 31, 33);
+    assertFieldStart(parser, false, 33, 34);
+    assertData(parser, "h", 34, 35);
+    assertFieldEnd(parser, 35, 36);
+    assertEmptyData(parser);
+    assertRangeEnd(parser, 42, 43);
+    assertRangeEnd(parser, 49, 50);
+    assertEnd(parser, 51, 51);
 }
 
 TEST(OsmlStreamParser, beginEndWithCommand)
@@ -834,16 +892,75 @@ TEST(OsmlStreamParser, beginEndWithCommand)
     //                         0         1           2
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
+
+    assertCommandStart(parser, "book", true, Variant::mapType{}, 7, 11);
+    assertCommand(parser, "a", 12, 14);
+    assertFieldStart(parser, false, 14, 15);
+    assertData(parser, "test", 15, 19);
+    assertFieldEnd(parser, 19, 20);
+    assertRangeEnd(parser, 25, 29);
+    assertEnd(parser, 30, 30);
+}
+
+TEST(OsmlStreamParser, beginEndNestedFields)
+{
+    const char *testString = "\\begin{book}a{{b{c}}}\\end{book}";
+    //                         012345678901234567890 1234567890
+    //                         0         1         2          3
+    CharReader charReader(testString);
+    OsmlStreamParser parser(charReader, logger);
+    logger.reset();
+
+    assertCommandStart(parser, "book", true, Variant::mapType{}, 7, 11);
+    assertData(parser, "a", 12, 13);
+    assertFieldStart(parser, false, 13, 14);
+    assertFieldStart(parser, false, 14, 15);
+    assertData(parser, "b", 15, 16);
+    assertFieldStart(parser, false, 16, 17);
+    assertData(parser, "c", 17, 18);
+    assertFieldEnd(parser, 18, 19);
+    assertFieldEnd(parser, 19, 20);
+    assertFieldEnd(parser, 20, 21);
+    assertRangeEnd(parser, 26, 30);
+    assertEnd(parser, 31, 31);
+}
+
+TEST(OsmlStreamParser, errorBeginEndUnbalancedNestedFields)
+{
+    const char *testString = "\\begin{book}a{{b{c}}\\end{book}";
+    //                         012345678901234567890 123456789
+    //                         0         1         2
+    CharReader charReader(testString);
+    OsmlStreamParser parser(charReader, logger);
+    logger.reset();
+
+    assertCommandStart(parser, "book", true, Variant::mapType{}, 7, 11);
+    assertData(parser, "a", 12, 13);
+    assertFieldStart(parser, false, 13, 14);
+    assertFieldStart(parser, false, 14, 15);
+    assertData(parser, "b", 15, 16);
+    assertFieldStart(parser, false, 16, 17);
+    assertData(parser, "c", 17, 18);
+    assertFieldEnd(parser, 18, 19);
+    assertFieldEnd(parser, 19, 20);
+    ASSERT_THROW(assertRangeEnd(parser, 25, 29), LoggableException);
+}
+
+TEST(OsmlStreamParser, errorBeginEndUnbalancedFields)
+{
+	const char *testString = "{a";
+	//                        01
+	CharReader charReader(testString);
+	OsmlStreamParser parser(charReader, logger);
 
-    assertCommand(reader, "book", 7, 11);
-    assertFieldStart(reader, true, 12, 13);
-    assertCommand(reader, "a", 12, 14);
-    assertFieldStart(reader, false, 14, 15);
-    assertData(reader, "test", 15, 19);
-    assertFieldEnd(reader, 19, 20);
-    assertFieldEnd(reader, 25, 29);
-    assertEnd(reader, 30, 30);
+	logger.reset();
+
+	assertFieldStart(parser, false, 0, 1);
+	assertTextData(parser, "a", 1, 2, 1, 2, WhitespaceMode::PRESERVE);
+	ASSERT_FALSE(logger.hasError());
+	assertEnd(parser, 2, 2);
+	ASSERT_TRUE(logger.hasError());
 }
 
 TEST(OsmlStreamParser, errorBeginNoBraceOpen)
@@ -852,12 +969,13 @@ TEST(OsmlStreamParser, errorBeginNoBraceOpen)
     //                         01234567
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
-    assertData(reader, "a", 7, 8);
+    assertData(parser, "a", 7, 8);
     ASSERT_TRUE(logger.hasError());
+    assertEnd(parser, 8, 8);
 }
 
 TEST(OsmlStreamParser, errorBeginNoIdentifier)
@@ -865,7 +983,7 @@ TEST(OsmlStreamParser, errorBeginNoIdentifier)
     const char *testString = "\\begin{!";
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
@@ -878,7 +996,7 @@ TEST(OsmlStreamParser, errorBeginNoBraceClose)
     const char *testString = "\\begin{a";
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
@@ -891,15 +1009,15 @@ TEST(OsmlStreamParser, errorBeginNoName)
     const char *testString = "\\begin{a#}";
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
-    assertCommand(reader, "a");
+    assertCommandStart(parser, "a", true);
     ASSERT_TRUE(logger.hasError());
     logger.reset();
     ASSERT_FALSE(logger.hasError());
-    assertEnd(reader);
+    assertEnd(parser);
     ASSERT_TRUE(logger.hasError());
 }
 
@@ -909,11 +1027,11 @@ TEST(OsmlStreamParser, errorEndNoBraceOpen)
     //                         012345
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
-    assertData(reader, "a", 5, 6);
+    assertData(parser, "a", 5, 6);
     ASSERT_TRUE(logger.hasError());
 }
 
@@ -922,7 +1040,7 @@ TEST(OsmlStreamParser, errorEndNoIdentifier)
     const char *testString = "\\end{!";
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
@@ -935,7 +1053,7 @@ TEST(OsmlStreamParser, errorEndNoBraceClose)
     const char *testString = "\\end{a";
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
@@ -948,7 +1066,7 @@ TEST(OsmlStreamParser, errorEndNoBegin)
     const char *testString = "\\end{a}";
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
@@ -963,14 +1081,13 @@ TEST(OsmlStreamParser, errorBeginEndMismatch)
     //                         0          1         2          3
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
-    assertCommand(reader, "a", 7, 8);
-    assertFieldStart(reader, true, 10, 11);
-    assertCommand(reader, "b", 17, 18);
-    assertFieldStart(reader, true, 20, 24);
-    assertData(reader, "test", 20, 24);
+    assertCommandStart(parser, "a", true, Variant::mapType{}, 7, 8);
+    assertEmptyData(parser);
+    assertCommandStart(parser, "b", true, Variant::mapType{}, 17, 18);
+    assertData(parser, "test", 20, 24);
     ASSERT_FALSE(logger.hasError());
     ASSERT_THROW(parser.parse(), LoggableException);
     ASSERT_TRUE(logger.hasError());
@@ -982,10 +1099,10 @@ TEST(OsmlStreamParser, commandWithNSSep)
     //                         012345678901
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertCommand(reader, "test1:test2", 0, 12);
-    assertEnd(reader, 12, 12);
+    assertCommand(parser, "test1:test2", 0, 12);
+    assertEnd(parser, 12, 12);
 }
 
 TEST(OsmlStreamParser, beginEndWithNSSep)
@@ -995,12 +1112,11 @@ TEST(OsmlStreamParser, beginEndWithNSSep)
     //                         0         1          2         3
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertCommand(reader, "test1:test2", 7, 18);
-    assertFieldStart(reader, true, 19, 20);
-    assertFieldEnd(reader, 24, 35);
-    assertEnd(reader, 36, 36);
+    assertCommandStart(parser, "test1:test2", true, Variant::mapType{}, 7, 18);
+    assertRangeEnd(parser, 24, 35);
+    assertEnd(parser, 36, 36);
 }
 
 TEST(OsmlStreamParser, errorBeginNSSep)
@@ -1008,15 +1124,14 @@ TEST(OsmlStreamParser, errorBeginNSSep)
     const char *testString = "\\begin:test{blub}\\end{blub}";
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
-    assertCommand(reader, "blub");
+    assertCommandStart(parser, "blub", true, Variant::mapType{});
     ASSERT_TRUE(logger.hasError());
-    assertFieldStart(reader, true);
-    assertFieldEnd(reader);
-    assertEnd(reader);
+    assertRangeEnd(parser);
+    assertEnd(parser);
 }
 
 TEST(OsmlStreamParser, errorEndNSSep)
@@ -1024,15 +1139,14 @@ TEST(OsmlStreamParser, errorEndNSSep)
     const char *testString = "\\begin{blub}\\end:test{blub}";
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
-    assertCommand(reader, "blub");
-    assertFieldStart(reader, true);
+    assertCommandStart(parser, "blub", true, Variant::mapType{});
     ASSERT_FALSE(logger.hasError());
-    assertFieldEnd(reader);
+    assertRangeEnd(parser);
     ASSERT_TRUE(logger.hasError());
-    assertEnd(reader);
+    assertEnd(parser);
 }
 
 TEST(OsmlStreamParser, errorEmptyNs)
@@ -1040,14 +1154,14 @@ TEST(OsmlStreamParser, errorEmptyNs)
     const char *testString = "\\test:";
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
-    assertCommand(reader, "test");
+    assertCommand(parser, "test");
     ASSERT_TRUE(logger.hasError());
-    assertData(reader, ":");
-    assertEnd(reader);
+    assertData(parser, ":");
+    assertEnd(parser);
 }
 
 TEST(OsmlStreamParser, errorRepeatedNs)
@@ -1055,14 +1169,14 @@ TEST(OsmlStreamParser, errorRepeatedNs)
     const char *testString = "\\test::";
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
-    assertCommand(reader, "test");
+    assertCommand(parser, "test");
     ASSERT_TRUE(logger.hasError());
-    assertData(reader, "::");
-    assertEnd(reader);
+    assertData(parser, "::");
+    assertEnd(parser);
 }
 
 TEST(OsmlStreamParser, explicitDefaultField)
@@ -1071,14 +1185,14 @@ TEST(OsmlStreamParser, explicitDefaultField)
     //                         01234567
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertCommand(reader, "a", 0, 2);
-    assertFieldStart(reader, true, 2, 4);
-    assertData(reader, "b", 4, 5);
-    assertFieldEnd(reader, 5, 6);
-    assertData(reader, "c", 6, 7);
-    assertEnd(reader, 7, 7);
+    assertCommand(parser, "a", 0, 2);
+    assertFieldStart(parser, true, 2, 4);
+    assertData(parser, "b", 4, 5);
+    assertFieldEnd(parser, 5, 6);
+    assertData(parser, "c", 6, 7);
+    assertEnd(parser, 7, 7);
 }
 
 TEST(OsmlStreamParser, explicitDefaultFieldWithCommand)
@@ -1087,33 +1201,33 @@ TEST(OsmlStreamParser, explicitDefaultFieldWithCommand)
     //                         0123 4567
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertCommand(reader, "a", 0, 2);
-    assertFieldStart(reader, true, 2, 4);
-    assertCommand(reader, "b", 4, 6);
-    assertFieldEnd(reader, 6, 7);
-    assertData(reader, "c", 7, 8);
-    assertEnd(reader, 8, 8);
+    assertCommand(parser, "a", 0, 2);
+    assertFieldStart(parser, true, 2, 4);
+    assertCommand(parser, "b", 4, 6);
+    assertFieldEnd(parser, 6, 7);
+    assertData(parser, "c", 7, 8);
+    assertEnd(parser, 8, 8);
 }
 
-TEST(OsmlStreamParser, errorFieldAfterExplicitDefaultField)
+TEST(OsmlStreamParser, fieldAfterExplicitDefaultField)
 {
     const char *testString = "\\a{!\\b}{c}";
     //                         0123 456789
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
-    assertCommand(reader, "a", 0, 2);
-    assertFieldStart(reader, true, 2, 4);
-    assertCommand(reader, "b", 4, 6);
-    assertFieldEnd(reader, 6, 7);
-    ASSERT_FALSE(logger.hasError());
-    assertData(reader, "c", 8, 9);
-    ASSERT_TRUE(logger.hasError());
-    assertEnd(reader, 10, 10);
+    assertCommand(parser, "a", 0, 2);
+    assertFieldStart(parser, true, 2, 4);
+    assertCommand(parser, "b", 4, 6);
+    assertFieldEnd(parser, 6, 7);
+    assertFieldStart(parser, false, 7, 8);
+    assertData(parser, "c", 8, 9);
+    assertFieldEnd(parser, 9, 10);
+    assertEnd(parser, 10, 10);
 }
 
 TEST(OsmlStreamParser, annotationStart)
@@ -1123,10 +1237,10 @@ TEST(OsmlStreamParser, annotationStart)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertAnnotationStart(reader, "a", Variant::mapType{}, 0, 3);
-    assertEnd(reader, 3, 3);
+    assertAnnotationStart(parser, "a", Variant::mapType{}, 0, 3);
+    assertEnd(parser, 3, 3);
 }
 
 TEST(OsmlStreamParser, annotationStartWithName)
@@ -1137,11 +1251,11 @@ TEST(OsmlStreamParser, annotationStartWithName)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertAnnotationStart(reader, "annotationWithName",
+    assertAnnotationStart(parser, "annotationWithName",
                           Variant::mapType{{"name", "aName"}}, 0, 20);
-    assertEnd(reader, 26, 26);
+    assertEnd(parser, 26, 26);
 }
 
 TEST(OsmlStreamParser, annotationStartWithArguments)
@@ -1152,12 +1266,12 @@ TEST(OsmlStreamParser, annotationStartWithArguments)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     assertAnnotationStart(
-        reader, "annotationWithName",
+        parser, "annotationWithName",
         Variant::mapType{{"name", "aName"}, {"a", 1}, {"b", 2}}, 0, 20);
-    assertEnd(reader, 35, 35);
+    assertEnd(parser, 35, 35);
 }
 
 TEST(OsmlStreamParser, simpleAnnotationStartBeginEnd)
@@ -1168,16 +1282,16 @@ TEST(OsmlStreamParser, simpleAnnotationStartBeginEnd)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     assertAnnotationStart(
-        reader, "ab", Variant::mapType{{"name", "name"}, {"a", 1}, {"b", 2}}, 8,
+        parser, "ab", Variant::mapType{{"name", "name"}, {"a", 1}, {"b", 2}}, 8,
         10);
-    assertFieldStart(reader, true, 26, 27);
-    assertData(reader, "a", 26, 27);
-    assertFieldEnd(reader, 33, 35);
-    assertAnnotationEnd(reader, "", "", 36, 38);
-    assertEnd(reader, 38, 38);
+    ASSERT_TRUE(parser.inRangeCommand());
+    assertData(parser, "a", 26, 27);
+    assertRangeEnd(parser, 33, 35);
+    assertAnnotationEnd(parser, "", "", 36, 38);
+    assertEnd(parser, 38, 38);
 }
 
 TEST(OsmlStreamParser, annotationEnd)
@@ -1187,10 +1301,10 @@ TEST(OsmlStreamParser, annotationEnd)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertAnnotationEnd(reader, "a", "", 0, 2);
-    assertEnd(reader, 3, 3);
+    assertAnnotationEnd(parser, "a", "", 0, 2);
+    assertEnd(parser, 3, 3);
 }
 
 TEST(OsmlStreamParser, annotationEndWithName)
@@ -1200,10 +1314,10 @@ TEST(OsmlStreamParser, annotationEndWithName)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertAnnotationEnd(reader, "a", "name", 0, 2);
-    assertEnd(reader, 8, 8);
+    assertAnnotationEnd(parser, "a", "name", 0, 2);
+    assertEnd(parser, 8, 8);
 }
 
 TEST(OsmlStreamParser, annotationEndWithNameAsArgs)
@@ -1213,10 +1327,10 @@ TEST(OsmlStreamParser, annotationEndWithNameAsArgs)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertAnnotationEnd(reader, "a", "name", 0, 2);
-    assertEnd(reader, 14, 14);
+    assertAnnotationEnd(parser, "a", "name", 0, 2);
+    assertEnd(parser, 14, 14);
 }
 
 TEST(OsmlStreamParser, errorAnnotationEndWithArguments)
@@ -1227,14 +1341,14 @@ TEST(OsmlStreamParser, errorAnnotationEndWithArguments)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
     logger.reset();
     ASSERT_FALSE(logger.hasError());
-    assertCommand(reader, "a", Variant::mapType{{"foo", "bar"}}, 0, 2);
+    assertCommandStart(parser, "a", false, Variant::mapType{{"foo", "bar"}}, 0, 2);
     ASSERT_TRUE(logger.hasError());
-    assertData(reader, ">", 11, 12);
-    assertEnd(reader, 12, 12);
+    assertData(parser, ">", 11, 12);
+    assertEnd(parser, 12, 12);
 }
 
 TEST(OsmlStreamParser, closingAnnotation)
@@ -1244,11 +1358,11 @@ TEST(OsmlStreamParser, closingAnnotation)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertAnnotationStart(reader, "a", Variant::mapType{}, 0, 3);
-    assertData(reader, ">", 3, 4);
-    assertEnd(reader, 4, 4);
+    assertAnnotationStart(parser, "a", Variant::mapType{}, 0, 3);
+    assertData(parser, ">", 3, 4);
+    assertEnd(parser, 4, 4);
 }
 
 TEST(OsmlStreamParser, annotationWithFields)
@@ -1259,23 +1373,23 @@ TEST(OsmlStreamParser, annotationWithFields)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
-
-    assertData(reader, "a", 0, 1);
-    assertAnnotationStart(reader, "b", Variant::mapType{}, 2, 5);
-    assertFieldStart(reader, false, 5, 6);
-    assertData(reader, "c", 6, 7);
-    assertFieldEnd(reader, 7, 8);
-    assertFieldStart(reader, false, 8, 9);
-    assertData(reader, "d", 9, 10);
-    assertFieldEnd(reader, 10, 11);
-    assertFieldStart(reader, true, 11, 13);
-    assertData(reader, "e", 13, 14);
-    assertFieldEnd(reader, 14, 15);
-    assertData(reader, "f", 16, 17);
-    assertAnnotationEnd(reader, "", "", 18, 20);
-    assertData(reader, "g", 21, 22);
-    assertEnd(reader, 22, 22);
+    OsmlStreamParser parser(charReader, logger);
+
+    assertData(parser, "a", 0, 1);
+    assertAnnotationStart(parser, "b", Variant::mapType{}, 2, 5);
+    assertFieldStart(parser, false, 5, 6);
+    assertData(parser, "c", 6, 7);
+    assertFieldEnd(parser, 7, 8);
+    assertFieldStart(parser, false, 8, 9);
+    assertData(parser, "d", 9, 10);
+    assertFieldEnd(parser, 10, 11);
+    assertFieldStart(parser, true, 11, 13);
+    assertData(parser, "e", 13, 14);
+    assertFieldEnd(parser, 14, 15);
+    assertData(parser, "f", 16, 17);
+    assertAnnotationEnd(parser, "", "", 18, 20);
+    assertData(parser, "g", 21, 22);
+    assertEnd(parser, 22, 22);
 }
 
 TEST(OsmlStreamParser, annotationStartEscape)
@@ -1286,11 +1400,11 @@ TEST(OsmlStreamParser, annotationStartEscape)
 
     CharReader charReader(testString);
 
-    OsmlStreamParser reader(charReader, logger);
+    OsmlStreamParser parser(charReader, logger);
 
-    assertData(reader, "<%test", 0, 7);
-    assertEnd(reader, 7, 7);
+    assertData(parser, "<%test", 0, 7);
+    assertEnd(parser, 7, 7);
 }
-*/
+
 }