1 files changed, 42 insertions, 32 deletions

diff --git a/spec/KeymapEvaluatorSpec.cpp b/spec/KeymapEvaluatorSpec.cpp
index 8e8ba87..0483e99 100644
--- a/spec/KeymapEvaluatorSpec.cpp
+++ b/spec/KeymapEvaluatorSpec.cpp
@@ -3,6 +3,7 @@
 
 #include "keymap/KeymapEvaluator.hpp"
 
+// NOLINTBEGIN
 class KeymapEvaluatorSpec : public QObject {
   Q_OBJECT
 
@@ -10,112 +11,121 @@ private slots:
   void test_evaluate_single_key_chord() {
     context("when the key sequence is mapped");
     it("calls mapping") {
-      int keymapWasCalled = false;
+      auto keymap_was_called = false;
       KeymapEvaluator evaluator;
-      evaluator.addKeymap(KeyMode::Normal, "<c-t>",
-                          [&keymapWasCalled]() { keymapWasCalled = true; });
+      evaluator.add_keymap(KeyMode::Normal, "<c-t>", [&keymap_was_called]() {
+        keymap_was_called = true;
+      });
 
       evaluator.evaluate(Qt::ControlModifier, Qt::Key_T);
 
-      QVERIFY(keymapWasCalled);
+      QVERIFY(keymap_was_called);
     }
 
     context("when the key sequence is not mapped");
     it("does not call mapping") {
-      int keymapWasCalled = false;
+      auto keymap_was_called = false;
       KeymapEvaluator evaluator;
-      evaluator.addKeymap(KeyMode::Normal, "<c-t>",
-                          [&keymapWasCalled]() { keymapWasCalled = true; });
+      evaluator.add_keymap(KeyMode::Normal, "<c-t>", [&keymap_was_called]() {
+        keymap_was_called = true;
+      });
 
       evaluator.evaluate(Qt::ControlModifier, Qt::Key_K);
 
-      QVERIFY(NOT keymapWasCalled);
+      QVERIFY(NOT keymap_was_called);
     }
   }
 
   void test_evaluate_multi_key_sequence() {
     context("when the full key sequence is mapped");
     it("calls mapping") {
-      int keymapWasCalled = false;
+      auto keymap_was_called = false;
       KeymapEvaluator evaluator;
-      evaluator.addKeymap(KeyMode::Normal, "<c-t>a",
-                          [&keymapWasCalled]() { keymapWasCalled = true; });
+      evaluator.add_keymap(KeyMode::Normal, "<c-t>a", [&keymap_was_called]() {
+        keymap_was_called = true;
+      });
 
       evaluator.evaluate(Qt::ControlModifier, Qt::Key_T);
       evaluator.evaluate(Qt::NoModifier, Qt::Key_A);
 
-      QVERIFY(keymapWasCalled);
+      QVERIFY(keymap_was_called);
     }
 
     context("when only part of a mapped key sequence is entered");
     it("does not call mapping") {
-      int keymapWasCalled = false;
+      auto keymap_was_called = false;
       KeymapEvaluator evaluator;
-      evaluator.addKeymap(KeyMode::Normal, "<c-t>a",
-                          [&keymapWasCalled]() { keymapWasCalled = true; });
+      evaluator.add_keymap(KeyMode::Normal, "<c-t>a", [&keymap_was_called]() {
+        keymap_was_called = true;
+      });
 
       evaluator.evaluate(Qt::ControlModifier, Qt::Key_T);
 
-      QVERIFY(NOT keymapWasCalled);
+      QVERIFY(NOT keymap_was_called);
     }
 
     context("when the key sequence is not mapped");
     it("does not call mapping") {
-      int keymapWasCalled = false;
+      auto keymap_was_called = false;
       KeymapEvaluator evaluator;
-      evaluator.addKeymap(KeyMode::Normal, "<c-t>a",
-                          [&keymapWasCalled]() { keymapWasCalled = true; });
+      evaluator.add_keymap(KeyMode::Normal, "<c-t>a", [&keymap_was_called]() {
+        keymap_was_called = true;
+      });
 
       evaluator.evaluate(Qt::ControlModifier, Qt::Key_K);
 
-      QVERIFY(NOT keymapWasCalled);
+      QVERIFY(NOT keymap_was_called);
     }
 
     context("when the key sequence is not mapped");
     it("does not call mapping") {
-      int keymapWasCalled = false;
+      auto keymap_was_called = false;
       KeymapEvaluator evaluator;
-      evaluator.addKeymap(KeyMode::Normal, "<c-t>a",
-                          [&keymapWasCalled]() { keymapWasCalled = true; });
+      evaluator.add_keymap(KeyMode::Normal, "<c-t>a", [&keymap_was_called]() {
+        keymap_was_called = true;
+      });
 
       evaluator.evaluate(Qt::ControlModifier, Qt::Key_T);
       evaluator.evaluate(Qt::NoModifier, Qt::Key_B);
 
-      QVERIFY(NOT keymapWasCalled);
+      QVERIFY(NOT keymap_was_called);
     }
 
     context("when an incorrect sequence is entered before the correct one");
     it("calls mapping") {
-      int keymapWasCalled = false;
+      auto keymap_was_called = false;
       KeymapEvaluator evaluator;
-      evaluator.addKeymap(KeyMode::Normal, "<c-t>a",
-                          [&keymapWasCalled]() { keymapWasCalled = true; });
+      evaluator.add_keymap(KeyMode::Normal, "<c-t>a", [&keymap_was_called]() {
+        keymap_was_called = true;
+      });
 
       evaluator.evaluate(Qt::ControlModifier, Qt::Key_T);
       evaluator.evaluate(Qt::NoModifier, Qt::Key_B);
       evaluator.evaluate(Qt::ControlModifier, Qt::Key_T);
       evaluator.evaluate(Qt::NoModifier, Qt::Key_A);
 
-      QVERIFY(keymapWasCalled);
+      QVERIFY(keymap_was_called);
     }
 
     // TODO: maybe fix this behavior
     context(
         "when partial mapped sequence is entered before an entire sequence");
     it("does not call mapping") {
-      int keymapWasCalled = false;
+      auto keymap_was_called = false;
       KeymapEvaluator evaluator;
-      evaluator.addKeymap(KeyMode::Normal, "<c-t>a",
-                          [&keymapWasCalled]() { keymapWasCalled = true; });
+      evaluator.add_keymap(KeyMode::Normal, "<c-t>a", [&keymap_was_called]() {
+        keymap_was_called = true;
+      });
 
       evaluator.evaluate(Qt::ControlModifier, Qt::Key_T);
       evaluator.evaluate(Qt::ControlModifier, Qt::Key_T);
       evaluator.evaluate(Qt::NoModifier, Qt::Key_A);
 
-      QVERIFY(NOT keymapWasCalled);
+      QVERIFY(NOT keymap_was_called);
     }
   }
 };
 
 QTEST_REGISTER(KeymapEvaluatorSpec)
 #include "KeymapEvaluatorSpec.moc"
+// NOLINTEND