Completed filter expression tests

Author: ritchiecarroll

src/sttp/data/filterexpressionparser.py

@@ -462,7 +462,7 @@ def exitIdentifierStatement(self, ctx: ExpressionParser.IdentifierStatementConte
         signalid = Empty.GUID
 
         if ctx.GUID_LITERAL() is not None:
-            signalid = UUID(ctx.GUID_LITERAL().getText())
+            signalid = FilterExpressionParser._parse_guidliteral(ctx.GUID_LITERAL().getText())
 
             if not self.track_filteredrows and not self.track_filteredsignalids:
                 # Handle edge case of encountering standalone Guid when not tracking rows or table identifiers.
@@ -930,13 +930,13 @@ def exitLiteralValue(self, ctx: ExpressionParser.LiteralValueContext):
 
                 if value > Limits.MAXINT32:
                     if value > Limits.MAXINT64:
-                        result = self._parse_numericliteral(literal)
+                        result = FilterExpressionParser._parse_numericliteral(literal)
                     else:
                         result = ValueExpression(ExpressionValueType.INT64, value)
                 else:
                     result = ValueExpression(ExpressionValueType.INT32, value)
             except Exception:
-                result = self._parse_numericliteral(literal)
+                result = FilterExpressionParser._parse_numericliteral(literal)
         elif ctx.NUMERIC_LITERAL() is not None:
             literal: str = ctx.NUMERIC_LITERAL().getText()
 
@@ -945,15 +945,15 @@ def exitLiteralValue(self, ctx: ExpressionParser.LiteralValueContext):
                 if "E" in literal.upper():
                     result = ValueExpression(ExpressionValueType.DOUBLE, float(literal))
                 else:
-                    result = self._parse_numericliteral(literal)
+                    result = FilterExpressionParser._parse_numericliteral(literal)
             except Exception:
-                result = self._parse_numericliteral(literal)
+                result = FilterExpressionParser._parse_numericliteral(literal)
         elif ctx.STRING_LITERAL() is not None:
-            result = ValueExpression(ExpressionValueType.STRING, self._parse_stringliteral(ctx.STRING_LITERAL().getText()))
+            result = ValueExpression(ExpressionValueType.STRING, FilterExpressionParser._parse_stringliteral(ctx.STRING_LITERAL().getText()))
         elif ctx.DATETIME_LITERAL() is not None:
-            result = ValueExpression(ExpressionValueType.DATETIME, self._parse_datetimeliteral(ctx.DATETIME_LITERAL().getText()))
+            result = ValueExpression(ExpressionValueType.DATETIME, FilterExpressionParser._parse_datetimeliteral(ctx.DATETIME_LITERAL().getText()))
         elif ctx.GUID_LITERAL() is not None:
-            result = ValueExpression(ExpressionValueType.GUID, self._parse_guidliteral(ctx.GUID_LITERAL().getText()))
+            result = ValueExpression(ExpressionValueType.GUID, FilterExpressionParser._parse_guidliteral(ctx.GUID_LITERAL().getText()))
         elif ctx.BOOLEAN_LITERAL() is not None:
             literal: str = ctx.BOOLEAN_LITERAL().getText()
             result = TRUEVALUE if literal.upper() == "TRUE" else FALSEVALUE
@@ -963,7 +963,8 @@ def exitLiteralValue(self, ctx: ExpressionParser.LiteralValueContext):
         if result is not None:
             self._add_expr(ctx, result)
 
-    def _parse_numericliteral(self, literal: str) -> ValueExpression:
+    @staticmethod
+    def _parse_numericliteral(literal: str) -> ValueExpression:
         try:
             value = Decimal(literal)
             return ValueExpression(ExpressionValueType.DECIMAL, value)
@@ -974,17 +975,20 @@ def _parse_numericliteral(self, literal: str) -> ValueExpression:
             except Exception:
                 return ValueExpression(ExpressionValueType.STRING, literal)
 
-    def _parse_stringliteral(self, literal: str) -> str:
+    @staticmethod
+    def _parse_stringliteral(literal: str) -> str:
         # Remove any surrounding quotes from string, ANTLR grammar already
         # ensures strings starting with quote also ends with one
         return literal[1:-1] if literal[0] == "'" else literal
 
-    def _parse_guidliteral(self, literal: str) -> UUID:
+    @staticmethod
+    def _parse_guidliteral(literal: str) -> UUID:
         # Remove any quotes from GUID (boost currently only handles optional braces),
         # ANTLR grammar already ensures GUID starting with quote also ends with one
         return UUID(literal[1:-1] if literal[0] in ["{", "'"] else literal)
 
-    def _parse_datetimeliteral(self, literal: str) -> datetime:
+    @staticmethod
+    def _parse_datetimeliteral(literal: str) -> datetime:
         # Remove any surrounding '#' symbols from date/time, ANTLR grammar already
         # ensures date/time starting with '#' symbol will also end with one
         literal = literal[1:-1] if literal[0] == "#" else literal

test/sttp/data/test_expressiontree.py

@@ -2074,3 +2074,30 @@ def test_misc_expressions(self):
 
         if result != 32:
             self.fail(f"test_misc_expressions: unexpected value expression result, expected 32, received {result}")
+
+    def test_filterexpression_statement_count(self):
+        dataset, _, _, statid, freqid = TestDataSet._create_dataset()
+
+        parser, err = FilterExpressionParser.from_dataset(dataset, f"{statid}; {{{freqid}}};'{statid}';Filter ActiveMeasurements Where True", "ActiveMeasurements")
+
+        if err is not None:
+            self.fail(f"test_filterexpression_statement_count: error executing FilterExpressionParser.from_dataset: {err}")
+
+        parser.track_filteredrows = False
+        parser.track_filteredsignalids = True
+
+        err = parser.evaluate(True, False)
+
+        if err is not None:
+            self.fail(f"test_filterexpression_statement_count: error executing parser.evaluate: {err}")
+
+        idset = parser.filtered_signalidset
+
+        if len(idset) != 2:
+            self.fail(f"test_filterexpression_statement_count: expected 2 signal IDs, received {len(idset)}")
+
+        if statid not in idset or freqid not in idset:
+            self.fail(f"test_filterexpression_statement_count: expected signal IDs {statid} and {freqid}, received {idset}")
+
+        if parser.filterexpression_statementcount != 4:
+            self.fail(f"test_filterexpression_statement_count: expected 4 statements, received {parser.filterexpression_statementcount}")