Adds parsing of step functions (#103)

resolves se-sic/VaRA#966

include/vara/Feature/Feature.h

@@ -4,6 +4,7 @@
 #include "vara/Feature/Constraint.h"
 #include "vara/Feature/FeatureSourceRange.h"
 #include "vara/Feature/FeatureTreeNode.h"
+#include "vara/Feature/StepFunction.h"
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
@@ -251,13 +252,16 @@ class NumericFeature : public Feature {
   NumericFeature(
       std::string Name, ValuesVariantType Values, bool Opt = false,
       std::vector<FeatureSourceRange> Loc = std::vector<FeatureSourceRange>(),
-      std::string OutputString = "")
+      std::string OutputString = "",
+      std::unique_ptr<StepFunction> Step = nullptr)
       : Feature(FeatureKind::FK_NUMERIC, std::move(Name), Opt, std::move(Loc),
                 std::move(OutputString)),
-        Values(std::move(Values)) {}
+        Values(std::move(Values)), Step(std::move(Step)) {}
 
   [[nodiscard]] ValuesVariantType getValues() const { return Values; }
 
+  [[nodiscard]] StepFunction *getStepFunction() { return Step.get(); }
+
   [[nodiscard]] string toString() const override;
 
   static bool classof(const Feature *F) {
@@ -266,6 +270,7 @@ class NumericFeature : public Feature {
 
 private:
   ValuesVariantType Values;
+  std::unique_ptr<StepFunction> Step;
 };
 
 //===----------------------------------------------------------------------===//

include/vara/Feature/StepFunction.h

@@ -0,0 +1,91 @@
+#ifndef VARA_FEATURE_STEPFUNCTION_H
+#define VARA_FEATURE_STEPFUNCTION_H
+
+#include "llvm/Support/FormatVariadic.h"
+
+#include <cmath>
+#include <memory>
+#include <variant>
+
+namespace vara::feature {
+
+//===----------------------------------------------------------------------===//
+//                             StepFunction Class
+//===----------------------------------------------------------------------===//
+
+class StepFunction {
+public:
+  enum class StepOperation { ADDITION, MULTIPLICATION, EXPONENTIATION };
+
+  using OperandVariantType = typename std::variant<std::string, double>;
+
+  StepFunction(OperandVariantType LHS, StepOperation Op, OperandVariantType RHS)
+      : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
+
+  StepFunction(StepOperation Op, double RHS) : StepFunction("x", Op, RHS) {}
+  StepFunction(double LHS, StepOperation Op) : StepFunction(LHS, Op, "x") {}
+
+  template <typename T = double>
+  [[nodiscard]] T next(T Value) {
+    if (std::holds_alternative<double>(RHS)) {
+      assert(std::holds_alternative<std::string>(LHS));
+      switch (Op) {
+      case StepOperation::ADDITION:
+        return Value + std::get<double>(RHS);
+      case StepOperation::MULTIPLICATION:
+        return Value * std::get<double>(RHS);
+      case StepOperation::EXPONENTIATION:
+        return std::pow(Value, std::get<double>(RHS));
+      }
+    }
+    assert(std::holds_alternative<double>(LHS));
+    switch (Op) {
+    case StepOperation::ADDITION:
+      return std::get<double>(LHS) + Value;
+    case StepOperation::MULTIPLICATION:
+      return std::get<double>(LHS) * Value;
+    case StepOperation::EXPONENTIATION:
+      return std::pow(std::get<double>(LHS), Value);
+    }
+  }
+
+  [[nodiscard]] double operator()(double Value) { return next(Value); }
+
+  [[nodiscard]] std::string toString() const {
+    if (std::holds_alternative<double>(RHS)) {
+      assert(std::holds_alternative<std::string>(LHS));
+      switch (Op) {
+      case StepOperation::ADDITION:
+        return llvm::formatv("{0} + {1}", std::get<std::string>(LHS),
+                             std::get<double>(RHS));
+      case StepOperation::MULTIPLICATION:
+        return llvm::formatv("{0} * {1}", std::get<std::string>(LHS),
+                             std::get<double>(RHS));
+      case StepOperation::EXPONENTIATION:
+        return llvm::formatv("{0} ^ {1}", std::get<std::string>(LHS),
+                             std::get<double>(RHS));
+      }
+    }
+    assert(std::holds_alternative<double>(LHS));
+    switch (Op) {
+    case StepOperation::ADDITION:
+      return llvm::formatv("{0} + {1}", std::get<double>(LHS),
+                           std::get<std::string>(RHS));
+    case StepOperation::MULTIPLICATION:
+      return llvm::formatv("{0} * {1}", std::get<double>(LHS),
+                           std::get<std::string>(RHS));
+    case StepOperation::EXPONENTIATION:
+      return llvm::formatv("{0} ^ {1}", std::get<double>(LHS),
+                           std::get<std::string>(RHS));
+    }
+  }
+
+private:
+  StepOperation Op;
+  OperandVariantType LHS;
+  OperandVariantType RHS;
+};
+
+} // namespace vara::feature
+
+#endif // VARA_FEATURE_STEPFUNCTION_H

include/vara/Feature/StepFunctionParser.h

@@ -0,0 +1,322 @@
+#ifndef VARA_FEATURE_STEPFUNCTIONPARSER_H
+#define VARA_FEATURE_STEPFUNCTIONPARSER_H
+
+#include "vara/Feature/StepFunction.h"
+
+#include <llvm/ADT/StringExtras.h>
+
+#include <deque>
+
+namespace vara::feature {
+
+//===----------------------------------------------------------------------===//
+//                           StepFunctionToken Class
+//===----------------------------------------------------------------------===//
+
+class StepFunctionToken {
+public:
+  enum class TokenKind {
+    IDENTIFIER,
+    NUMBER,
+    WHITESPACE,
+    PLUS,
+    STAR,
+    CARET,
+    END_OF_FILE,
+    ERROR
+  };
+
+  StepFunctionToken(TokenKind Kind) : Kind(Kind) {}
+  StepFunctionToken(TokenKind Kind, const std::string &Value)
+      : Kind(Kind), Value(Value) {}
+  virtual ~StepFunctionToken() = default;
+
+  [[nodiscard]] TokenKind getKind() const { return Kind; };
+
+  [[nodiscard]] llvm::Optional<const std::string> getValue() const {
+    return Value;
+  }
+
+private:
+  const TokenKind Kind;
+  const llvm::Optional<const std::string> Value{llvm::None};
+};
+
+//===----------------------------------------------------------------------===//
+//                           StepFunctionLexer Class
+//===----------------------------------------------------------------------===//
+
+class StepFunctionLexer {
+public:
+  using TokenListTy = std::deque<StepFunctionToken>;
+
+  explicit StepFunctionLexer(std::string Cnt) : Cnt(std::move(Cnt)) {}
+
+  [[nodiscard]] TokenListTy tokenize() {
+    TokenListTy TokenList;
+
+    for (llvm::StringRef Str = Cnt; !Str.empty();) {
+      auto Result = munch(Str);
+      TokenList.push_back(Result.first);
+      if (auto Kind = Result.first.getKind();
+          Kind == StepFunctionToken::TokenKind::END_OF_FILE ||
+          Kind == StepFunctionToken::TokenKind::ERROR) {
+        break;
+      }
+      Str = Str.drop_front(Result.second);
+    }
+
+    // ensure last token is always either EOF or an error
+    if (auto Kind = TokenList.back().getKind();
+        Kind != StepFunctionToken::TokenKind::END_OF_FILE &&
+        Kind != StepFunctionToken::TokenKind::ERROR) {
+      TokenList.push_back(
+          StepFunctionToken(StepFunctionToken::TokenKind::END_OF_FILE));
+    }
+
+    return TokenList;
+  }
+
+private:
+  using ResultTy = std::pair<StepFunctionToken, int>;
+
+  static ResultTy munch(const llvm::StringRef Str) {
+    if (('a' <= Str.front() && Str.front() <= 'z') ||
+        ('A' <= Str.front() && Str.front() <= 'Z')) {
+      return munchIdentifier(Str);
+    }
+    if (('0' <= Str.front() && Str.front() <= '9') || Str.front() == '.') {
+      return munchNumber(Str);
+    }
+
+    switch (Str.front()) {
+    case EOF:
+    case '\0':
+      return {StepFunctionToken(StepFunctionToken::TokenKind::END_OF_FILE), 1};
+    case ' ':
+    case '\t':
+    case '\r':
+    case '\n':
+      return munchWhitespace(Str);
+    case '+':
+      return {StepFunctionToken(StepFunctionToken::TokenKind::PLUS), 1};
+    case '*':
+      return {StepFunctionToken(StepFunctionToken::TokenKind::STAR), 1};
+    case '^':
+      return {StepFunctionToken(StepFunctionToken::TokenKind::CARET), 1};
+    default:
+      return {StepFunctionToken(StepFunctionToken::TokenKind::ERROR,
+                                Str.take_front().str()),
+              1};
+    }
+  }
+
+  static ResultTy munchWhitespace(const llvm::StringRef &Str) {
+    auto Munch = Str.take_while(
+        [](auto C) { return C == ' ' || C == '\t' || C == '\r' || C == '\n'; });
+    return {StepFunctionToken(StepFunctionToken::TokenKind::WHITESPACE),
+            Munch.size()};
+  }
+
+  static ResultTy munchNumber(const llvm::StringRef &Str) {
+    auto Munch =
+        Str.take_while([](auto C) { return llvm::isDigit(C) || C == '.'; });
+    return {
+        StepFunctionToken(StepFunctionToken::TokenKind::NUMBER, Munch.lower()),
+        Munch.size()};
+  }
+
+  static ResultTy munchIdentifier(const llvm::StringRef &Str) {
+    auto Munch =
+        Str.take_while([](auto C) { return llvm::isAlnum(C) || C == '_'; });
+    return {StepFunctionToken(StepFunctionToken::TokenKind::IDENTIFIER,
+                              Munch.str()),
+            Munch.size()};
+  }
+
+  std::string Cnt;
+};
+
+//===----------------------------------------------------------------------===//
+//                          StepFunctionParser Class
+//===----------------------------------------------------------------------===//
+
+class StepFunctionParser {
+public:
+  explicit StepFunctionParser(std::string Cnt,
+                              llvm::Optional<unsigned int> Line = llvm::None)
+      : TokenList(StepFunctionLexer(std::move(Cnt)).tokenize()), Line(Line) {}
+
+  [[nodiscard]] std::unique_ptr<StepFunction> buildStepFunction() {
+    return parseStepFunction();
+  }
+
+private:
+  [[nodiscard]] const StepFunctionToken &peek() const {
+    return TokenList.front();
+  }
+
+  [[nodiscard]] StepFunctionToken next() {
+    auto Token = TokenList.front();
+    TokenList.pop_front();
+    return Token;
+  }
+
+  bool consume(const StepFunctionToken::TokenKind Kind) {
+    if (TokenList.front().getKind() == Kind) {
+      TokenList.pop_front();
+      return true;
+    }
+    return false;
+  }
+
+  llvm::Optional<StepFunction::OperandVariantType> parseOperand() {
+    while (!TokenList.empty()) {
+      switch (peek().getKind()) {
+      case StepFunctionToken::TokenKind::ERROR:
+        assert(peek().getValue().hasValue());
+        llvm::errs() << "Lexical error: Unexpected character '"
+                     << *peek().getValue() << "'\n";
+        return llvm::None;
+      case StepFunctionToken::TokenKind::END_OF_FILE:
+        llvm::errs() << "Syntax error: Unexpected end of expression.\n";
+        return llvm::None;
+      case StepFunctionToken::TokenKind::WHITESPACE:
+        consume(StepFunctionToken::TokenKind::WHITESPACE);
+        continue;
+      case StepFunctionToken::TokenKind::PLUS:
+        llvm::errs() << "Lexical error: Unexpected operator '+'.\n";
+        return llvm::None;
+      case StepFunctionToken::TokenKind::STAR:
+        llvm::errs() << "Lexical error: Unexpected operator '*'.\n";
+        return llvm::None;
+      case StepFunctionToken::TokenKind::CARET:
+        llvm::errs() << "Lexical error: Unexpected operator '^'.\n";
+        return llvm::None;
+      case StepFunctionToken::TokenKind::IDENTIFIER:
+        assert(peek().getValue().hasValue());
+        return {*next().getValue()};
+      case StepFunctionToken::TokenKind::NUMBER:
+        assert(peek().getValue().hasValue());
+        double Number;
+        llvm::StringRef(*next().getValue()).getAsDouble(Number);
+        return {Number};
+      }
+    }
+    return llvm::None;
+  }
+
+  llvm::Optional<StepFunction::StepOperation> parseOperator() {
+    while (!TokenList.empty()) {
+      switch (peek().getKind()) {
+      case StepFunctionToken::TokenKind::ERROR:
+        assert(peek().getValue().hasValue());
+        llvm::errs() << "Lexical error: Unexpected character '"
+                     << *peek().getValue() << "'\n";
+        return llvm::None;
+      case StepFunctionToken::TokenKind::END_OF_FILE:
+        llvm::errs() << "Syntax error: Unexpected end of expression.\n";
+        return llvm::None;
+      case StepFunctionToken::TokenKind::WHITESPACE:
+        consume(StepFunctionToken::TokenKind::WHITESPACE);
+        continue;
+      case StepFunctionToken::TokenKind::PLUS:
+        consume(StepFunctionToken::TokenKind::PLUS);
+        return StepFunction::StepOperation::ADDITION;
+      case StepFunctionToken::TokenKind::STAR:
+        consume(StepFunctionToken::TokenKind::STAR);
+        return StepFunction::StepOperation::MULTIPLICATION;
+      case StepFunctionToken::TokenKind::CARET:
+        consume(StepFunctionToken::TokenKind::CARET);
+        return StepFunction::StepOperation::EXPONENTIATION;
+      case StepFunctionToken::TokenKind::IDENTIFIER:
+        assert(peek().getValue().hasValue());
+        llvm::errs() << "Syntax error: Unexpected identifier '"
+                     << *peek().getValue() << "'\n";
+        return llvm::None;
+      case StepFunctionToken::TokenKind::NUMBER:
+        assert(peek().getValue().hasValue());
+        llvm::errs() << "Syntax error: Unexpected number '"
+                     << *peek().getValue() << "'\n";
+        return llvm::None;
+      }
+    }
+    return llvm::None;
+  }
+
+  bool parseEOF() {
+    while (!TokenList.empty()) {
+      switch (peek().getKind()) {
+      case StepFunctionToken::TokenKind::ERROR:
+        assert(peek().getValue().hasValue());
+        llvm::errs() << "Lexical error: Unexpected character '"
+                     << *peek().getValue() << "'\n";
+        return false;
+      case StepFunctionToken::TokenKind::END_OF_FILE:
+        return true;
+      case StepFunctionToken::TokenKind::WHITESPACE:
+        consume(StepFunctionToken::TokenKind::WHITESPACE);
+        continue;
+      case StepFunctionToken::TokenKind::PLUS:
+        llvm::errs() << "Lexical error: Unexpected operator '+'.\n";
+        return false;
+      case StepFunctionToken::TokenKind::STAR:
+        llvm::errs() << "Lexical error: Unexpected operator '*'.\n";
+        return false;
+      case StepFunctionToken::TokenKind::CARET:
+        llvm::errs() << "Lexical error: Unexpected operator '^'.\n";
+        return false;
+      case StepFunctionToken::TokenKind::IDENTIFIER:
+        assert(peek().getValue().hasValue());
+        llvm::errs() << "Syntax error: Unexpected identifier '"
+                     << *peek().getValue() << "'\n";
+        return false;
+      case StepFunctionToken::TokenKind::NUMBER:
+        assert(peek().getValue().hasValue());
+        llvm::errs() << "Syntax error: Unexpected number '"
+                     << *peek().getValue() << "'\n";
+        return false;
+      }
+    }
+    return false;
+  }
+
+  std::unique_ptr<StepFunction> parseStepFunction() {
+    auto LHS = parseOperand();
+    if (!LHS.hasValue()) {
+      return nullptr;
+    }
+    auto Op = parseOperator();
+    if (!Op.hasValue()) {
+      return nullptr;
+    }
+    auto RHS = parseOperand();
+    if (!RHS.hasValue()) {
+      return nullptr;
+    }
+    if (!parseEOF()) {
+      return nullptr;
+    }
+
+    if (std::holds_alternative<std::string>(LHS.getValue()) &&
+        std::holds_alternative<std::string>(RHS.getValue())) {
+      llvm::errs() << "Syntax error: Missing constant.\n";
+      return nullptr;
+    }
+    if (std::holds_alternative<double>(LHS.getValue()) &&
+        std::holds_alternative<double>(RHS.getValue())) {
+      llvm::errs() << "Syntax error: Missing operand.\n";
+      return nullptr;
+    }
+
+    return std::make_unique<StepFunction>(LHS.getValue(), Op.getValue(),
+                                          RHS.getValue());
+  }
+
+  StepFunctionLexer::TokenListTy TokenList;
+  llvm::Optional<unsigned int> Line;
+};
+
+} // namespace vara::feature
+
+#endif // VARA_FEATURE_STEPFUNCTIONPARSER_H

lib/Feature/FeatureModelParser.cpp

@@ -2,6 +2,7 @@
 #include "vara/Feature/ConstraintParser.h"
 #include "vara/Feature/Feature.h"
 #include "vara/Feature/FeatureSourceRange.h"
+#include "vara/Feature/StepFunctionParser.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/FormatVariadic.h"
@@ -31,6 +32,7 @@ FeatureModelXmlParser::parseConfigurationOption(xmlNode *Node,
   int64_t MaxValue = 0;
   std::vector<int64_t> Values;
   std::vector<FeatureSourceRange> SourceRanges;
+  std::unique_ptr<StepFunction> Step;
   for (xmlNode *Head = Node->children; Head; Head = Head->next) {
     if (Head->type == XML_ELEMENT_NODE) {
       std::string Cnt{trim(reinterpret_cast<char *>(
@@ -119,6 +121,8 @@ FeatureModelXmlParser::parseConfigurationOption(xmlNode *Node,
                Suffix = Matches.suffix()) {
             Values.emplace_back(parseInteger(Matches.str(), Head->line));
           }
+        } else if (!xmlStrcmp(Head->name, XmlConstants::STEPFUNCTION)) {
+          Step = StepFunctionParser(Cnt, Head->line).buildStepFunction();
         }
       }
     }
@@ -131,10 +135,11 @@ FeatureModelXmlParser::parseConfigurationOption(xmlNode *Node,
     if (Values.empty()) {
       FMB.makeFeature<NumericFeature>(Name, std::make_pair(MinValue, MaxValue),
                                       Opt, std::move(SourceRanges),
-                                      OutputString);
+                                      OutputString, std::move(Step));
     } else {
       FMB.makeFeature<NumericFeature>(Name, Values, Opt,
-                                      std::move(SourceRanges), OutputString);
+                                      std::move(SourceRanges), OutputString,
+                                      std::move(Step));
     }
   } else {
     FMB.makeFeature<BinaryFeature>(Name, Opt, std::move(SourceRanges),

unittests/Feature/CMakeLists.txt

@@ -14,4 +14,6 @@ add_vara_unittest(VaRAFeatureUnitTests VaRAFeatureTests
   OrderedFeatureVector.cpp
   Relationship.cpp
   RootFeature.cpp
+  StepFunction.cpp
+  StepFunctionParser.cpp
   )

unittests/Feature/FeatureModelParser.cpp

@@ -127,6 +127,20 @@ TEST(FeatureModelParser, outputString) {
   EXPECT_EQ(F->getOutputString(), "-a");
 }
 
+TEST(FeatureModelParser, stepFunction) {
+  auto FM = buildFeatureModel("test_step_function.xml");
+  ASSERT_TRUE(FM);
+
+  if (auto *F = llvm::dyn_cast_or_null<NumericFeature>(FM->getFeature("A"));
+      F) {
+    auto *S = F->getStepFunction();
+    ASSERT_TRUE(S);
+    EXPECT_DOUBLE_EQ((*S)(12.42), 54.42);
+  } else {
+    FAIL();
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                        XMLAlternatives
 //===----------------------------------------------------------------------===//

unittests/Feature/StepFunction.cpp

@@ -0,0 +1,84 @@
+#include "vara/Feature/StepFunction.h"
+
+#include "gtest/gtest.h"
+
+namespace vara::feature {
+
+template <typename T>
+class StepFunctionTest : public ::testing::Test {
+protected:
+  static void checkEqual(T V1, T V2) { EXPECT_EQ(V1, V2); }
+
+  static void checkStepFunction(T Start, StepFunction *S,
+                                const std::function<T(T)> &F) {
+    T Next = Start;
+    T Expected = Start;
+    for (int Step = 0; Step < STEPS; ++Step) {
+      Next = S->next<T>(Next);
+      Expected = F(Expected);
+      checkEqual(Next, Expected);
+    }
+  }
+
+private:
+  static const int STEPS = 10;
+};
+template <>
+void StepFunctionTest<float>::checkEqual(float V1, float V2) {
+  EXPECT_FLOAT_EQ(V1, V2);
+}
+template <>
+void StepFunctionTest<double>::checkEqual(double V1, double V2) {
+  EXPECT_DOUBLE_EQ(V1, V2);
+}
+
+using types = ::testing::Types<double, float, long, int, unsigned int>;
+TYPED_TEST_SUITE(StepFunctionTest, types, );
+
+TYPED_TEST(StepFunctionTest, addition) {
+  auto S = StepFunction(StepFunction::StepOperation::ADDITION, 13.37);
+  TestFixture::checkStepFunction(-100, &S,
+                                 [](TypeParam X) { return X + 13.37; });
+}
+
+TYPED_TEST(StepFunctionTest, multiplication) {
+  auto S = StepFunction(StepFunction::StepOperation::MULTIPLICATION, -13.37);
+  TestFixture::checkStepFunction(1, &S, [](TypeParam X) { return X * -13.37; });
+}
+
+TYPED_TEST(StepFunctionTest, exponentiationL) {
+  auto S = StepFunction(StepFunction::StepOperation::EXPONENTIATION, 2);
+  TestFixture::checkStepFunction(1, &S,
+                                 [](TypeParam X) { return std::pow(X, 2); });
+}
+
+TYPED_TEST(StepFunctionTest, exponentiationR) {
+  auto S = StepFunction(2, StepFunction::StepOperation::EXPONENTIATION);
+  TestFixture::checkStepFunction(1, &S,
+                                 [](TypeParam X) { return std::pow(2, X); });
+}
+
+TEST(StepFunction, commutative) {
+  auto L = StepFunction(StepFunction::StepOperation::MULTIPLICATION, 13.37);
+  auto R = StepFunction(13.37, StepFunction::StepOperation::MULTIPLICATION);
+
+  EXPECT_DOUBLE_EQ(L(42), R(42));
+}
+
+TEST(StepFunction, next) {
+  auto S = StepFunction(StepFunction::StepOperation::MULTIPLICATION, 13.37);
+
+  EXPECT_DOUBLE_EQ(S.next<double>(42), 561.54);
+  EXPECT_DOUBLE_EQ(S.next(42.), 561.54);
+  EXPECT_EQ(S.next<int>(42.), 561);
+  EXPECT_EQ(S.next(42), 561);
+}
+
+TEST(StepFunction, call) {
+  auto S = StepFunction(StepFunction::StepOperation::MULTIPLICATION, 13.37);
+
+  EXPECT_DOUBLE_EQ(S(42.), 561.54);
+  EXPECT_DOUBLE_EQ(S(42), 561.54);
+}
+
+} // namespace vara::feature

unittests/Feature/StepFunctionParser.cpp

@@ -0,0 +1,117 @@
+#include "vara/Feature/StepFunctionParser.h"
+
+#include "gtest/gtest.h"
+
+namespace vara::feature {
+
+TEST(StepFunctionLexer, error) {
+  StepFunctionLexer L("x# 42");
+
+  auto TokenList = L.tokenize();
+  ASSERT_EQ(TokenList.size(), 2);
+
+  EXPECT_EQ(TokenList[0].getKind(), StepFunctionToken::TokenKind::IDENTIFIER);
+  EXPECT_EQ(*TokenList[0].getValue(), "x");
+  EXPECT_EQ(TokenList[1].getKind(), StepFunctionToken::TokenKind::ERROR);
+  EXPECT_EQ(*TokenList[1].getValue(), "#");
+}
+
+TEST(StepFunctionLexer, end) {
+  StepFunctionLexer L("x\0 42"); // NOLINT
+
+  auto TokenList = L.tokenize();
+  ASSERT_EQ(TokenList.size(), 2);
+
+  EXPECT_EQ(TokenList[0].getKind(), StepFunctionToken::TokenKind::IDENTIFIER);
+  EXPECT_EQ(*TokenList[0].getValue(), "x");
+  EXPECT_EQ(TokenList[1].getKind(), StepFunctionToken::TokenKind::END_OF_FILE);
+}
+
+class StepFunctionLexerTest : public ::testing::Test {
+protected:
+  static void checkPrimary(StepFunctionToken::TokenKind Kind,
+                           const std::string &Repr) {
+    auto TokenList = StepFunctionLexer(Repr).tokenize();
+    ASSERT_EQ(TokenList.size(), 2);
+
+    EXPECT_EQ(TokenList[0].getKind(), Kind);
+    EXPECT_EQ(TokenList[1].getKind(),
+              StepFunctionToken::TokenKind::END_OF_FILE);
+  }
+
+  static void checkBinary(StepFunctionToken::TokenKind Kind,
+                          const std::string &Repr) {
+    auto TokenList = StepFunctionLexer("x" + Repr + "42").tokenize();
+    ASSERT_EQ(TokenList.size(), 4);
+
+    EXPECT_EQ(TokenList[0].getKind(), StepFunctionToken::TokenKind::IDENTIFIER);
+    EXPECT_EQ(*TokenList[0].getValue(), "x");
+    EXPECT_EQ(TokenList[1].getKind(), Kind);
+    EXPECT_EQ(TokenList[2].getKind(), StepFunctionToken::TokenKind::NUMBER);
+    EXPECT_EQ(*TokenList[2].getValue(), "42");
+    EXPECT_EQ(TokenList[3].getKind(),
+              StepFunctionToken::TokenKind::END_OF_FILE);
+  }
+};
+
+TEST_F(StepFunctionLexerTest, tokenize) {
+  checkPrimary(StepFunctionToken::TokenKind::IDENTIFIER, "x");
+  checkPrimary(StepFunctionToken::TokenKind::NUMBER, "42");
+  checkPrimary(StepFunctionToken::TokenKind::NUMBER, "0.5");
+  checkPrimary(StepFunctionToken::TokenKind::NUMBER, ".5");
+  checkPrimary(StepFunctionToken::TokenKind::WHITESPACE, " ");
+  checkPrimary(StepFunctionToken::TokenKind::WHITESPACE, "\n");
+  checkPrimary(StepFunctionToken::TokenKind::WHITESPACE, "\r");
+  checkPrimary(StepFunctionToken::TokenKind::WHITESPACE, "\t");
+  checkBinary(StepFunctionToken::TokenKind::PLUS, "+");
+  checkBinary(StepFunctionToken::TokenKind::STAR, "*");
+  checkBinary(StepFunctionToken::TokenKind::CARET, "^");
+}
+
+TEST(StepFunctionParser, error) {
+  EXPECT_FALSE(StepFunctionParser("x 42").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("x#42").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("x +").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("+ x").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("x").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("1 2").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("x + 1 + 2").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("x + 1 * 2").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("x + 1 ^ 2").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("x + y").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("1 + 2").buildStepFunction());
+  EXPECT_FALSE(StepFunctionParser("1 2 +").buildStepFunction());
+}
+
+class StepFunctionParserTest : public ::testing::Test {
+protected:
+  static void checkStepFunction(double Current, double Next,
+                                const std::string &Repr) {
+    auto L = StepFunctionParser(Repr).buildStepFunction();
+    ASSERT_TRUE(L);
+
+    EXPECT_DOUBLE_EQ((*L)(Current), Next);
+  }
+
+  static void checkStepFunction(double Current, double Next,
+                                const std::string &Left,
+                                const std::string &Right) {
+    checkStepFunction(Current, Next, Left);
+    checkStepFunction(Current, Next, Right);
+  }
+};
+
+TEST_F(StepFunctionParserTest, expressions) {
+  checkStepFunction(0, 0, "x+0", "0+x");
+  checkStepFunction(-3, 2, "x+5", "5+x");
+  checkStepFunction(42, 0, "x*0", "0*x");
+  checkStepFunction(1.5, 3, "x*2", "2*x");
+  checkStepFunction(3, 1.5, "x*.5", ".5*x");
+  checkStepFunction(0, 1, "x^0", "0^x");
+  checkStepFunction(3, 9, "x^2");
+  checkStepFunction(3, 8, "2^x");
+  checkStepFunction(9, 3, "x^.5");
+  checkStepFunction(2, .25, ".5^x");
+}
+
+} // namespace vara::feature

unittests/resources/CMakeLists.txt

@@ -27,6 +27,7 @@ set(FEATURE_LIB_TEST_FILES
   xml/test_only_parents.xml
   xml/test_out_of_order.xml
   xml/test_output_string.xml
+  xml/test_step_function.xml
   xml/test_with_whitespaces.xml
   )
 

unittests/resources/xml/test_step_function.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE vm SYSTEM "vm.dtd">
+<vm name="ABC" root="test">
+  <binaryOptions>
+  </binaryOptions>
+  <numericOptions>
+    <configurationOption>
+      <name>A</name>
+      <parent>root</parent>
+      <optional>True</optional>
+      <minValue>0</minValue>
+      <maxValue>100</maxValue>
+      <stepFunction>x + 42</stepFunction>
+    </configurationOption>
+  </numericOptions>
+</vm>