tiwiq/tests/Executor.cpp

#include <catch2/catch.hpp>
#include "../src/core/Tiwiq.hpp"
#include "../src/core/Executor.hpp"

using namespace twq::core;

class ExecutorTest
{
public:
  explicit ExecutorTest() {}
  virtual ~ExecutorTest() {}

  Context get_context()
  {
    return Context {m_tiwiq};
  }

protected:
  twq::core::Tiwiq m_tiwiq;
};

struct CommandMock: public Command
{
  int execute_count = 0;

  void execute(Context&) override
  {
    execute_count++;
  }

  void undo(Context&) override
  {
  }
};

TEST_CASE_METHOD(ExecutorTest, "Executor_one_key")
{
  Context ctx = get_context();
  auto cmd = std::make_shared<CommandMock>();
  Binding b {std::make_shared<Shortcut>(L"a"), cmd};

  Executor exec;
  exec.register_binding(b);

  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"a"});
  REQUIRE(1 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"a"});
  REQUIRE(2 == cmd->execute_count);
}

TEST_CASE_METHOD(ExecutorTest, "Executor_two_same_keys")
{
  Context ctx = get_context();
  auto cmd = std::make_shared<CommandMock>();
  Binding b {std::make_shared<Shortcut>(L"a a"), cmd};

  Executor exec;
  exec.register_binding(b);

  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"a"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"a"});
  REQUIRE(1 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"a"});
  REQUIRE(1 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"a"});
  REQUIRE(2 == cmd->execute_count);
}

TEST_CASE_METHOD(ExecutorTest, "Executor_two_keys")
{
  Context ctx = get_context();

  auto cmd = std::make_shared<CommandMock>();
  Binding b {std::make_shared<Shortcut>(L"a b"), cmd};

  Executor exec;
  exec.register_binding(b);

  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"a"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"b"});
  REQUIRE(1 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"a"});
  REQUIRE(1 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"b"});
  REQUIRE(2 == cmd->execute_count);
}


TEST_CASE_METHOD(ExecutorTest, "Executor_wrong_key")
{
  Context ctx = get_context();

  auto cmd = std::make_shared<CommandMock>();
  Binding b {std::make_shared<Shortcut>(L"a b"), cmd};

  Executor exec;
  exec.register_binding(b);

  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"a"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"c"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"b"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"a"});
  REQUIRE(0 == cmd->execute_count);
  exec.update(ctx, KeyMod {L"b"});
  REQUIRE(1 == cmd->execute_count);
}


TEST_CASE_METHOD(ExecutorTest, "Executor_two_commands")
{
  Context ctx = get_context();

  auto cmd0 = std::make_shared<CommandMock>();
  Binding b0 {std::make_shared<Shortcut>(L"C-a b"), cmd0};

  auto cmd1 = std::make_shared<CommandMock>();
  Binding b1 {std::make_shared<Shortcut>(L"C-a c"), cmd1};

  Executor exec;
  exec.register_binding(b0);
  exec.register_binding(b1);

  SECTION("execute first")
    {
      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"C-a"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"b"});

      REQUIRE(1 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
    }

    SECTION("execute second")
    {
      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"C-a"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"c"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(1 == cmd1->execute_count);
    }

    SECTION("fail first, try but fail second")
    {
      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"C-a"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"d"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"b"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
    }
}

TEST_CASE_METHOD(ExecutorTest, "Executor_two_sequentials_commands")
{
  Context ctx = get_context();

  auto cmd0 = std::make_shared<CommandMock>();
  Binding b0 {std::make_shared<Shortcut>(L"C-a b"), cmd0};

  auto cmd1 = std::make_shared<CommandMock>();
  Binding b1 {std::make_shared<Shortcut>(L"b c"), cmd1};

  Executor exec;
  exec.register_binding(b0);
  exec.register_binding(b1);

  SECTION("execute sequentially")
    {
      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"C-a"});

      REQUIRE(0 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"b"});

      REQUIRE(1 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"c"});

      REQUIRE(1 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"b"});

      REQUIRE(1 == cmd0->execute_count);
      REQUIRE(0 == cmd1->execute_count);
      exec.update(ctx, KeyMod {L"c"});

      REQUIRE(1 == cmd0->execute_count);
      REQUIRE(1 == cmd1->execute_count);
    }
}