Update tests

Author: lucic71

tests/unit/lambda_as_field.cpp

@@ -0,0 +1,45 @@
+// ADDITIONAL_COMPILE_FLAGS: -std=c++23
+#include <assert.h>
+
+template <typename F> struct Guard {
+  F f;
+  ~Guard() { f(); }
+};
+
+template <typename F> struct Holder {
+  F f;
+  int calls;
+  int call(int x) {
+    calls++;
+    return f(x);
+  }
+};
+
+template <typename T> auto wrap(T fn) {
+  return [fn](int x) { return fn(x) + 1; };
+}
+
+int main() {
+  int cleaned = 0;
+  {
+    Guard g{[&cleaned]() { cleaned++; }};
+    assert(cleaned == 0);
+  }
+  assert(cleaned == 1);
+
+  int factor = 3;
+  Holder h{[factor](int x) { return x * factor; }, 0};
+  factor = 100;
+  assert(h.call(2) == 6);
+  assert(h.call(5) == 15);
+  assert(h.calls == 2);
+
+  auto w = wrap([factor](int x) { return x * factor; });
+  factor = 7;
+  assert(w(2) == 201);
+
+  auto ww = wrap(w);
+  assert(ww(2) == 202);
+
+  return 0;
+}

tests/unit/lambda_as_template_argument.cpp

@@ -0,0 +1,27 @@
+#include <assert.h>
+
+template <typename F> int apply_int(F fn, int x) { return fn(x); }
+
+template <typename F> double apply_double(F fn, double x) { return fn(x); }
+
+template <typename F> int apply_twice(F fn, int x) { return fn(fn(x)); }
+
+int main() {
+  int factor = 3;
+  auto scale = [factor](int x) { return x * factor; };
+  assert(apply_twice(scale, 4) == 36);
+
+  assert(apply_int([](int x) { return -x; }, 9) == -9);
+
+  auto generic_scale = [factor](auto x) { return x * factor; };
+  assert(apply_int(generic_scale, 4) == 12);
+  assert(apply_double(generic_scale, 1.5) == 4.5);
+
+  assert(apply_int([](auto x) { return -x; }, 9) == -9);
+
+  auto offset = [factor]<typename T>(T x) { return x + factor; };
+  assert(apply_int(offset, 4) == 7);
+  assert(apply_double(offset, 1.5) == 4.5);
+
+  return 0;
+}

tests/unit/lambda_basic.cpp

@@ -0,0 +1,14 @@
+#include <assert.h>
+
+int main() {
+  auto zero = []() { return 42; };
+  assert(zero() == 42);
+
+  auto one = [](int x) { return x + 1; };
+  assert(one(1) == 2);
+
+  auto three = [](int x, int y, int z) { return x * 100 + y * 10 + z; };
+  assert(three(1, 2, 3) == 123);
+
+  return 0;
+}

tests/unit/lambda_capture_copy_ctor.cpp

@@ -0,0 +1,35 @@
+#include <assert.h>
+#include <utility>
+
+struct Counted {
+  int copies;
+  int moves;
+  Counted() : copies(0), moves(0) {}
+  Counted(const Counted &o) : copies(o.copies + 1), moves(o.moves) {}
+  Counted(Counted &&o) : copies(o.copies), moves(o.moves + 1) {}
+};
+
+int main() {
+  Counted c;
+  auto f = [c]() { return c.copies * 10 + c.moves; };
+  assert(f() == 10);
+
+  auto g = f;
+  assert(g() == 20);
+  assert(f() == 10);
+
+  auto h = std::move(f);
+  assert(h() == 11);
+
+  int returned = [c]() { return c; }().copies;
+  assert(returned == 2);
+
+  Counted arr[2];
+  auto a = [arr]() { return arr[0].copies + arr[1].copies; };
+  assert(a() == 2);
+
+  auto a2 = a;
+  assert(a2() == 4);
+
+  return 0;
+}

tests/unit/lambda_capture_implicit.cpp

@@ -0,0 +1,26 @@
+#include <assert.h>
+
+int main() {
+  int a = 1;
+  int b = 2;
+  int c = 3;
+
+  auto by_value = [=](int x) { return a + b + c + x; };
+  assert(by_value(10) == 16);
+  a = 100;
+  assert(by_value(10) == 16);
+
+  auto by_ref = [&](int x) { return a + b + c + x; };
+  assert(by_ref(10) == 115);
+  b = 200;
+  assert(by_ref(10) == 313);
+
+  auto mixed = [=, &c](int x) {
+    c += x;
+    return a + b + c;
+  };
+  assert(mixed(1) == 100 + 200 + 4);
+  assert(c == 4);
+
+  return 0;
+}

tests/unit/lambda_capture_pass.cpp

@@ -0,0 +1,40 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+
+struct S {
+  int x;
+  int y;
+};
+
+int main() {
+  int base = 10;
+  auto add_base = [&base](int x) { return x + base; };
+  assert(add_base(5) == 15);
+  base = 100;
+  assert(add_base(5) == 105);
+
+  S s = {1, 2};
+  auto sum = [&s]() { return s.x + s.y; };
+  assert(sum() == 3);
+  s.x = 50;
+  assert(sum() == 52);
+
+  int counter = 0;
+  auto bump = [&counter]() { counter++; };
+  bump();
+  bump();
+  assert(counter == 2);
+
+  uint16_t arr[4] = {3, 1, 2, 0};
+  auto swap = [&arr](size_t i, size_t j) {
+    uint16_t t = arr[j];
+    arr[j] = arr[i];
+    arr[i] = t;
+  };
+  swap(0, 3);
+  assert(arr[0] == 0);
+  assert(arr[3] == 3);
+
+  return 0;
+}

tests/unit/lambda_capture_ref.cpp

@@ -0,0 +1,41 @@
+#include <assert.h>
+
+struct S {
+  int n;
+  int twice() const { return n * 2; }
+
+  int modify_copy() {
+    auto f = [*this]() mutable {
+      n += 10;
+      return n;
+    };
+    int r = f();
+    return r * 100 + n;
+  }
+
+  int snapshot() {
+    auto f = [*this]() { return twice(); };
+    n = 99;
+    return f();
+  }
+
+  int mixed(int k) {
+    auto f = [=, *this]() { return n + k; };
+    n = 0;
+    return f();
+  }
+};
+
+int main() {
+  S s = {1};
+  assert(s.modify_copy() == 1101);
+  assert(s.n == 1);
+
+  assert(s.snapshot() == 2);
+  assert(s.n == 99);
+
+  assert(s.mixed(1) == 100);
+  assert(s.n == 0);
+
+  return 0;
+}

tests/unit/lambda_capture_star_this.cpp

@@ -0,0 +1,31 @@
+#include <assert.h>
+
+struct S {
+  int n;
+  int step;
+  void add(int k) { n += k; }
+  int scaled() const { return n * step; }
+  void bump(int by) {
+    auto inc = [this](int k) { n += k; };
+    inc(by);
+    inc(by);
+  }
+  void bump_via_method(int by) {
+    auto inc = [this](int k) { add(k); };
+    inc(by);
+  }
+  int read_scaled() const {
+    auto get = [this]() { return scaled(); };
+    return get();
+  }
+};
+
+int main() {
+  S s = {0, 2};
+  s.bump(3);
+  assert(s.n == 6);
+  s.bump_via_method(4);
+  assert(s.n == 10);
+  assert(s.read_scaled() == 20);
+  return 0;
+}

tests/unit/lambda_capture_this.cpp

@@ -0,0 +1,31 @@
+#include <assert.h>
+
+struct S {
+  int x;
+  int y;
+};
+
+int main() {
+  int factor = 3;
+  auto scale = [factor](int x) { return x * factor; };
+  assert(scale(4) == 12);
+  factor = 100;
+  assert(scale(4) == 12);
+
+  int slot = 7;
+  int *p = &slot;
+  auto read_ptr = [p]() { return *p; };
+  slot = 8;
+  assert(read_ptr() == 8);
+
+  S s = {1, 2};
+  auto sum = [s]() { return s.x + s.y; };
+  s.x = 50;
+  assert(sum() == 3);
+
+  int base = 10;
+  auto shifted = [y = base + 1](int x) { return x + y; };
+  assert(shifted(5) == 16);
+
+  return 0;
+}