Get GitHub actions working (#1)

Author: lefticus

.github/workflows/build_cmake.yml

@@ -20,25 +20,14 @@ jobs:
       # We'll use this as our working directory for all subsequent commands
       run: cmake -E make_directory ${{runner.workspace}}/build
 
-    - name: Install conan
-      shell: bash
-      if: contains( matrix.os , "linux")
-      run: |
-        python3 -m pip install --upgrade pip setuptools
-        python3 -m pip install conan
-        source ~/.profile
-
-    - name: Install conan
-      shell: bash
-      if: contains(matrix.os, "windows")
-      run: |
-        pip install conan
 
     - name: Install conan
       shell: bash
-      if: contains(matrix.os, "macos")
       run: |
-        pip install conan
+        which pip3 && pip3 --version || pip --version
+        which pip3 && pip3 install conan || pip install conan
+        [[ -f ~/.profile ]] && source ~/.profile
+        conan --version
 
     - name: Configure CMake
       # Use a bash shell so we can use the same syntax for environment variable
@@ -51,7 +40,7 @@ jobs:
       # 
       # We need to source the profile file to make sure conan is in PATH
       run: |
-        source ~/.profile
+        [[ -f ~/.profile ]] && source ~/.profile
         cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=${{matrix.buildtype}}
 
     - name: Build

include/lambda_coroutines/lambda_coroutines.hpp

@@ -1,6 +1,9 @@
 #ifndef LAMBDA_COROUTINES_HPP
 #define LAMBDA_COROUTINES_HPP
 
+#include <cstddef>
+#include <optional>
+#include <utility>
 
 // because these are macros we cannot meaningfully use namespaces
 
@@ -28,14 +31,18 @@ constexpr void lambda_co_status_check(ParamType &value)
   switch (state_variable) {                                    \
   default:                                                     \
   case 0:
+
 #define lambda_co_return(return_value) \
   }                                    \
   return return_value
+
 #define lambda_co_yield(yield_value)                              \
   coroutine_lambda_internal_state_ref = LAMBDA_CO_CONSTEXPR_LINE; \
   return yield_value;                                             \
   case LAMBDA_CO_CONSTEXPR_LINE:
 
+#define lambda_co_end() }
+
 template<typename Lambda>
 [[nodiscard]] constexpr auto range(
   Lambda lambda,

test/constexpr_tests.cpp

@@ -1,3 +1,6 @@
+#include <array>
+#include <utility>
+
 #include <catch2/catch.hpp>
 #include "lambda_coroutines/lambda_coroutines.hpp"
 
@@ -32,7 +35,7 @@ constexpr std::array<unsigned long long, 5> get_first_5()
   return { fib().value(), fib().value(), fib().value(), fib().value(), fib().value() };
 }
 
-TEST_CASE("lambda_coroutines are constexpr capable", "[lambda_coroutines]")
+TEST_CASE("lambda_coroutines are constexpr capable", "[constexpr]")
 {
   STATIC_REQUIRE(get_first_5()[4] == 3ULL);
 }

test/tests.cpp

@@ -1,3 +1,83 @@
 #include <catch2/catch.hpp>
+#include "lambda_coroutines/lambda_coroutines.hpp"
 
-// to-do non-constexpr tests
+TEST_CASE("Generate infinite sequence")
+{
+  enum struct directions {
+    Left,
+    Right,
+    Up,
+    Down
+  };
+
+  auto next_direction = [state=0]() mutable {
+    lambda_co_begin(state);
+
+    while (true) {
+      lambda_co_yield(directions::Left);
+      lambda_co_yield(directions::Right);
+      lambda_co_yield(directions::Up);
+      lambda_co_yield(directions::Down);
+    }
+
+    lambda_co_end();
+  };
+
+  REQUIRE(next_direction() == directions::Left);
+  REQUIRE(next_direction() == directions::Right);
+  REQUIRE(next_direction() == directions::Up);
+  REQUIRE(next_direction() == directions::Down);
+  REQUIRE(next_direction() == directions::Left);
+  REQUIRE(next_direction() == directions::Right);
+}
+
+TEST_CASE("Cooperative multi tasking")
+{
+  enum OpCodes : std::uint8_t {
+    ADD = 0,
+    STA = 1,
+    NOP = 2
+  };
+  struct Machine {
+    std::uint8_t PC{0};
+    std::uint8_t A{0};
+    std::array<uint8_t, 256> RAM{STA, 10, ADD, 15};
+  };
+
+  Machine machine;
+
+  auto CPU = [state = 0, &machine, op = OpCodes::NOP]() mutable {
+    lambda_co_begin(state);
+
+    while(true) {
+      op = static_cast<OpCodes>(machine.RAM[machine.PC]);
+      ++machine.PC;
+      if (op == OpCodes::STA) {
+        lambda_co_yield();
+        machine.A = machine.RAM[machine.PC++];
+        lambda_co_yield();
+      } else if (op == OpCodes::ADD) {
+        lambda_co_yield();
+        machine.A += machine.RAM[machine.PC++];
+        lambda_co_yield();
+      } else if (op == OpCodes::NOP) {
+        lambda_co_yield();
+      };
+    }
+
+    lambda_co_end();
+  };
+
+  CPU();
+  REQUIRE(machine.PC == 1);
+  REQUIRE(machine.A == 0);
+  CPU();
+  REQUIRE(machine.PC == 2);
+  REQUIRE(machine.A == 10);
+  CPU();
+  REQUIRE(machine.PC == 3);
+  REQUIRE(machine.A == 10);
+  CPU();
+  REQUIRE(machine.PC == 4);
+  REQUIRE(machine.A == 25);
+}