test_delegate.cpp

#include <cassert>
#include <cmath>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>

#include "delegate.hpp"

#define TEST(name) static void name()
#define RUN(name)                     \
  do {                                \
    std::cout << "  " #name "... ";   \
    name();                           \
    std::cout << "PASS" << std::endl; \
  } while (0)

// --- Basic functionality ---

TEST(test_lambda_add_and_broadcast) {
  Delegate<void(int)> d;
  int sum = 0;
  d.add([&sum](int x) { sum += x; });
  d.add([&sum](int x) { sum += x * 2; });
  d.broadcast(5);
  assert(sum == 15);  // 5 + 10
}

TEST(test_return_values) {
  Delegate<float(float)> d;
  d.add([](float x) { return x * 2.0f; });
  d.add([](float x) { return x * 3.0f; });
  auto results = d.broadcast(4.0f);
  assert(results.size() == 2);
  assert(results[0] == 8.0f);
  assert(results[1] == 12.0f);
}

TEST(test_remove_by_handle) {
  Delegate<void()> d;
  int count = 0;
  auto h1 = d.add([&count]() { count++; });
  auto h2 = d.add([&count]() { count++; });
  (void)h2;
  d.broadcast();
  assert(count == 2);

  d.remove(h1);
  // After remove(Handle by value), h1 is NOT modified
  count = 0;
  d.broadcast();
  assert(count == 1);
}

TEST(test_remove_by_function_pointer) {
  Delegate<float(float)> d;
  struct Fns {
    static float double_it(float x) { return x * 2; }
    static float triple_it(float x) { return x * 3; }
  };
  d.add(&Fns::double_it);
  d.add(&Fns::triple_it);
  d.remove(&Fns::double_it);
  auto results = d.broadcast(5.0f);
  assert(results.size() == 1);
  assert(results[0] == 15.0f);
}

TEST(test_member_function_raw_pointer) {
  struct Counter {
    int value = 0;
    void increment(int n) { value += n; }
  };
  Delegate<void(int)> d;
  Counter c;
  d.add(&c, &Counter::increment);
  d.broadcast(7);
  assert(c.value == 7);
}

TEST(test_add_weak_and_expiry) {
  struct Greeter {
    std::string greet() { return "hello"; }
  };
  Delegate<std::string()> d;
  auto obj = std::make_shared<Greeter>();
  d.add_weak(obj, &Greeter::greet);
  assert(d.size() == 1);

  auto results = d.broadcast();
  assert(results.size() == 1);
  assert(results[0] == "hello");

  obj.reset();  // destroy the object
  results = d.broadcast();
  assert(results.size() == 0);  // expired weak_ptr was removed during broadcast
  assert(d.size() == 0);        // cleaned up
}

TEST(test_remove_all_for_object) {
  struct Obj {
    void fn1() {}
    void fn2() {}
  };
  Delegate<void()> d;
  Obj o;
  d.add(&o, &Obj::fn1);
  d.add(&o, &Obj::fn2);
  assert(d.size() == 2);
  d.remove_all_for_object(&o);
  assert(d.size() == 0);
}

TEST(test_contains) {
  Delegate<void()> d;
  auto h = d.add([]() {});
  assert(d.contains(h));
  d.remove(h);
  assert(!d.contains(h));
  assert(!d.contains(Delegate<void()>::InvalidHandle));
}

TEST(test_empty_and_size) {
  Delegate<void()> d;
  assert(d.empty());
  assert(d.size() == 0);
  auto h = d.add([]() {});
  assert(!d.empty());
  assert(d.size() == 1);
  d.remove(h);
  assert(d.empty());
}

TEST(test_clear) {
  Delegate<void()> d;
  d.add([]() {});
  d.add([]() {});
  assert(d.size() == 2);
  d.clear();
  assert(d.size() == 0);
}

TEST(test_operator_parentheses) {
  Delegate<int(int)> d;
  d.add([](int x) { return x + 1; });
  auto results = d(10);
  assert(results.size() == 1);
  assert(results[0] == 11);
}

TEST(test_error_handler) {
  Delegate<void()> d;
  d.add([]() { throw std::runtime_error("oops"); });
  d.add([]() { /* no-op */ });

  int error_count = 0;
  d.set_error_handler([&error_count](const std::exception_ptr&) { error_count++; });
  d.broadcast();
  assert(error_count == 1);
}

TEST(test_copy_semantics) {
  Delegate<void(int)> d1;
  int sum = 0;
  d1.add([&sum](int x) { sum += x; });

  Delegate<void(int)> d2 = d1;  // copy
  d2.broadcast(5);
  assert(sum == 5);

  d1.broadcast(10);
  assert(sum == 15);  // both have the callback
}

TEST(test_move_semantics) {
  Delegate<void(int)> d1;
  int sum = 0;
  d1.add([&sum](int x) { sum += x; });

  Delegate<void(int)> d2 = std::move(d1);
  assert(d1.size() == 0);
  d2.broadcast(3);
  assert(sum == 3);
}

// --- Thread safety ---

TEST(test_concurrent_add_and_broadcast) {
  Delegate<void(int)> d;
  std::atomic<int> sum{0};

  std::thread t1([&] {
    for (int i = 0; i < 1000; i++) {
      d.add([&sum](int x) { sum.fetch_add(x); });
    }
  });

  std::thread t2([&] {
    for (int i = 0; i < 1000; i++) {
      d.broadcast(1);
    }
  });

  t1.join();
  t2.join();
  // No crashes = success. sum value is non-deterministic.
  std::cout << "(sum=" << sum.load() << ") ";
}

TEST(test_concurrent_remove_and_broadcast) {
  Delegate<void()> d;
  std::atomic<int> count{0};
  std::vector<Delegate<void()>::Handle> handles;

  for (int i = 0; i < 100; i++) {
    handles.push_back(d.add([&count]() { count.fetch_add(1); }));
  }

  std::thread t1([&] {
    for (auto& h : handles) {
      d.remove(h);
    }
  });

  std::thread t2([&] {
    for (int i = 0; i < 50; i++) {
      d.broadcast();
    }
  });

  t1.join();
  t2.join();
  // No crashes = success.
}

int main() {
  std::cout << "Running delegate tests..." << std::endl;

  RUN(test_lambda_add_and_broadcast);
  RUN(test_return_values);
  RUN(test_remove_by_handle);
  RUN(test_remove_by_function_pointer);
  RUN(test_member_function_raw_pointer);
  RUN(test_add_weak_and_expiry);
  RUN(test_remove_all_for_object);
  RUN(test_contains);
  RUN(test_empty_and_size);
  RUN(test_clear);
  RUN(test_operator_parentheses);
  RUN(test_error_handler);
  RUN(test_copy_semantics);
  RUN(test_move_semantics);
  RUN(test_concurrent_add_and_broadcast);
  RUN(test_concurrent_remove_and_broadcast);

  std::cout << "\nAll tests passed!" << std::endl;
  return 0;
}