Improve codecov results (#9)

* refactor: ♻️ Increase codevoc

Exclude certain directories from codecov and remove unused AssertionSpan

* test: ✅ Add assertion parsing tests

.github/codecov.yml

@@ -3,6 +3,9 @@ ignore:
   - "**/python"
   - "test/**/*"
   - "src/mqt/debug/dap/**/*"
+  - "src/mqt/debug/dap/*"
+  - "app/*"
+  - "src/frontend/**/*"
 
 coverage:
   range: 60..90

include/common/parsing/AssertionParsing.hpp

@@ -10,7 +10,6 @@
 enum class AssertionType : uint8_t {
   Entanglement,
   Superposition,
-  Span,
   StatevectorEquality,
   CircuitEquality
 };
@@ -36,17 +35,6 @@ class SuperpositionAssertion : public Assertion {
   explicit SuperpositionAssertion(std::vector<std::string> targetQubits);
 };
 
-class SpanAssertion : public Assertion {
-  std::vector<Statevector> spanVectors;
-
-public:
-  SpanAssertion(std::vector<Statevector> spanVectors,
-                std::vector<std::string> targetQubits);
-  [[nodiscard]] const std::vector<Statevector>& getSpanVectors() const;
-
-  ~SpanAssertion() override;
-};
-
 class EqualityAssertion : public Assertion {
   double similarityThreshold;
 

src/backend/dd/DDSimDebug.cpp

@@ -955,12 +955,6 @@ bool checkAssertionSuperposition(
   return found > 1;
 }
 
-[[noreturn]] bool
-checkAssertionSpan([[maybe_unused]] DDSimulationState* ddsim,
-                   [[maybe_unused]] std::unique_ptr<SpanAssertion>& assertion) {
-  throw std::runtime_error("Span assertions are not implemented");
-}
-
 bool checkAssertionEqualityStatevector(
     DDSimulationState* ddsim,
     std::unique_ptr<StatevectorEqualityAssertion>& assertion) {
@@ -1044,11 +1038,6 @@ bool checkAssertion(DDSimulationState* ddsim,
     assertion = std::move(superpositionAssertion);
     return result;
   }
-  if (assertion->getType() == AssertionType::Span) {
-    std::unique_ptr<SpanAssertion> spanAssertion(
-        dynamic_cast<SpanAssertion*>(assertion.release()));
-    checkAssertionSpan(ddsim, spanAssertion);
-  }
   if (assertion->getType() == AssertionType::StatevectorEquality) {
     std::unique_ptr<StatevectorEqualityAssertion> svEqualityAssertion(
         dynamic_cast<StatevectorEqualityAssertion*>(assertion.release()));

src/common/parsing/AssertionParsing.cpp

@@ -4,6 +4,7 @@
 #include "common/parsing/ParsingError.hpp"
 #include "common/parsing/Utils.hpp"
 
+#include <algorithm>
 #include <cmath>
 #include <cstddef>
 #include <memory>
@@ -30,27 +31,6 @@ SuperpositionAssertion::SuperpositionAssertion(
     std::vector<std::string> inputTargetQubits)
     : Assertion(std::move(inputTargetQubits), AssertionType::Superposition) {}
 
-SpanAssertion::SpanAssertion(std::vector<Statevector> inputSpanVectors,
-                             std::vector<std::string> inputTargetQubits)
-    : Assertion(std::move(inputTargetQubits), AssertionType::Span),
-      spanVectors(std::move(inputSpanVectors)) {
-  for (auto& statevector : spanVectors) {
-    if (statevector.numQubits != getTargetQubits().size()) {
-      throw ParsingError(
-          "Number of target qubits must match number of qubits in statevector");
-    }
-  }
-}
-const std::vector<Statevector>& SpanAssertion::getSpanVectors() const {
-  return spanVectors;
-}
-SpanAssertion::~SpanAssertion() {
-  for (auto& statevector : spanVectors) {
-    // NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
-    delete[] statevector.amplitudes;
-  }
-}
-
 EqualityAssertion::EqualityAssertion(double inputSimilarityThreshold,
                                      std::vector<std::string> inputTargetQubits,
                                      AssertionType assertionType)
@@ -93,7 +73,10 @@ const std::string& CircuitEqualityAssertion::getCircuitCode() const {
 }
 
 std::vector<std::string> extractTargetQubits(const std::string& targetPart) {
-  return splitString(targetPart, ',');
+  const auto parts = splitString(targetPart, ',');
+  std::vector<std::string> trimmedParts(parts.size());
+  std::transform(parts.begin(), parts.end(), trimmedParts.begin(), trim);
+  return trimmedParts;
 }
 
 Complex parseComplex(std::string complexString) {
@@ -143,7 +126,6 @@ bool isAssertion(std::string expression) {
   expression = trim(expression);
   return startsWith(expression, "assert-ent") ||
          startsWith(expression, "assert-sup") ||
-         startsWith(expression, "assert-span") ||
          startsWith(expression, "assert-eq");
 }
 
@@ -159,25 +141,6 @@ std::unique_ptr<Assertion> parseAssertion(std::string assertionString,
     auto targets = extractTargetQubits(assertionString.substr(11));
     return std::make_unique<SuperpositionAssertion>(targets);
   }
-  if (startsWith(assertionString, "assert-span")) {
-    auto sub = assertionString.substr(12);
-    auto targets = extractTargetQubits(sub);
-    auto statevectors = splitString(blockContent, ';');
-    std::vector<Statevector> statevectorList(statevectors.size());
-    for (auto& statevector : statevectors) {
-      statevectorList.emplace_back(parseStatevector(statevector));
-    }
-
-    auto assertion = std::make_unique<SpanAssertion>(statevectorList, targets);
-    auto svSize = statevectorList[0].numStates;
-    for (auto& sv : statevectorList) {
-      if (sv.numStates != svSize) {
-        throw ParsingError(
-            "Statevectors in span assertion must have the same size");
-      }
-    }
-    return assertion;
-  }
   if (startsWith(assertionString, "assert-eq")) {
     auto sub = assertionString.substr(10);
     auto targets = extractTargetQubits(sub);

test/CMakeLists.txt

@@ -6,7 +6,8 @@ package_add_test(
   test_simulation.cpp
   test_data_retrieval.cpp
   test_diagnostics.cpp
-  test_custom_code.cpp)
+  test_custom_code.cpp
+  test_parsing.cpp)
 
 # set include directories
 target_include_directories(mqt_debug_test PUBLIC ${PROJECT_SOURCE_DIR}/test/utils)

test/test_custom_code.cpp

@@ -97,3 +97,14 @@ TEST_F(CustomCodeTest, GateInGateName) {
            "assert-eq q[0] { 0, 1 }");
   state->runSimulation(state);
 }
+
+TEST_F(CustomCodeTest, EqualityAssertion) {
+  loadCode(2, 0,
+           "h q[0];"
+           "cx q[0], q[1];"
+           "assert-eq 0.9, q[0], q[1] { 0.707, 0, 0, 0.707 }"
+           "assert-eq q[0], q[1] { qreg q[2]; h q[1]; cx q[1], q[0]; }");
+  size_t numErrors = 0;
+  ASSERT_EQ(state->runAll(state, &numErrors), OK);
+  ASSERT_EQ(numErrors, 0);
+}

test/test_parsing.cpp

@@ -0,0 +1,64 @@
+#include "common/parsing/AssertionParsing.hpp"
+#include "common/parsing/ParsingError.hpp"
+
+#include <gtest/gtest.h>
+#include <memory>
+#include <string>
+
+class ParsingTest : public testing::Test {
+  void SetUp() override {}
+};
+
+TEST_F(ParsingTest, EqualityAssertion) {
+  // With statevector
+  const auto a1 = parseAssertion("assert-eq 0.5, q[0]", "1, 0");
+  ASSERT_EQ(a1->getType(), AssertionType::StatevectorEquality);
+  ASSERT_EQ(a1->getTargetQubits().size(), 1);
+  ASSERT_EQ(a1->getTargetQubits()[0], "q[0]");
+  const auto* sv = dynamic_cast<StatevectorEqualityAssertion*>(a1.get());
+  ASSERT_EQ(sv->getSimilarityThreshold(), 0.5);
+  ASSERT_EQ(sv->getTargetStatevector().numQubits, 1);
+  ASSERT_EQ(sv->getTargetStatevector().numStates, 2);
+  ASSERT_EQ(sv->getTargetStatevector().amplitudes->real, 1);
+
+  // With circuit
+  const auto a2 = parseAssertion("assert-eq 0.5, q[0]", "qreg q[1]; h q[0];");
+  ASSERT_EQ(a2->getType(), AssertionType::CircuitEquality);
+  ASSERT_EQ(a2->getTargetQubits().size(), 1);
+  ASSERT_EQ(a2->getTargetQubits()[0], "q[0]");
+  const auto* c = dynamic_cast<CircuitEqualityAssertion*>(a2.get());
+  ASSERT_EQ(c->getSimilarityThreshold(), 0.5);
+  ASSERT_EQ(c->getCircuitCode(), "qreg q[1]; h q[0];");
+}
+
+TEST_F(ParsingTest, EntanglementAssertion) {
+  const auto a = parseAssertion("assert-ent q[0], q[1]", "");
+  ASSERT_EQ(a->getType(), AssertionType::Entanglement);
+  ASSERT_EQ(a->getTargetQubits().size(), 2);
+  ASSERT_EQ(a->getTargetQubits()[0], "q[0]");
+  ASSERT_EQ(a->getTargetQubits()[1], "q[1]");
+}
+
+TEST_F(ParsingTest, SuperpositionAssertion) {
+  const auto a = parseAssertion("assert-sup q[0], q[1]", "");
+  ASSERT_EQ(a->getType(), AssertionType::Superposition);
+  ASSERT_EQ(a->getTargetQubits().size(), 2);
+  ASSERT_EQ(a->getTargetQubits()[0], "q[0]");
+  ASSERT_EQ(a->getTargetQubits()[1], "q[1]");
+}
+
+TEST_F(ParsingTest, ErrorStatevectorEqualityAssertion) {
+  ASSERT_THROW(parseAssertion("assert-eq 1.5, q[0]", "1, 0"), ParsingError);
+  ASSERT_THROW(parseAssertion("assert-eq 0.5, q[0]", "1, 0, 0"), ParsingError);
+  ASSERT_THROW(parseAssertion("assert-eq 0.5, q[0]", "1, 0, 0, 0"),
+               ParsingError);
+}
+
+TEST_F(ParsingTest, ErrorCircuitEqualityAssertion) {
+  ASSERT_THROW(parseAssertion("assert-eq 1.5, q[0]", "qreg q[1]; h q[0];"),
+               ParsingError);
+}
+
+TEST_F(ParsingTest, ErrorInvalidAssertion) {
+  ASSERT_THROW(parseAssertion("assert-fake q[0]", ""), ParsingError);
+}