linus/fahnen_esp32
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

imported from "final" folder

Browse Source
This commit is contained in:
Linus Beine
2025-11-28 12:12:50 +01:00
parent f9288986cf
commit ff8e725b35
1061 changed files with 225150 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
.pio/libdeps/esp01_1m/FastLED/tests/test_await.cpp Normal file
View File

@@ -0,0 +1,191 @@
#include "test.h"
#include "fl/async.h"
#include "fl/promise.h"
using namespace fl;
TEST_CASE("fl::await_top_level - Basic Operations") {
SUBCASE("await_top_level resolved promise returns value") {
auto promise = fl::promise<int>::resolve(42);
auto result = fl::await_top_level(promise); // Type automatically deduced!
CHECK(result.ok());
CHECK_EQ(result.value(), 42);
}
SUBCASE("await_top_level rejected promise returns error") {
auto promise = fl::promise<int>::reject(Error("Test error"));
auto result = fl::await_top_level(promise); // Type automatically deduced!
CHECK(!result.ok());
CHECK_EQ(result.error().message, "Test error");
}
SUBCASE("await_top_level invalid promise returns error") {
fl::promise<int> invalid_promise; // Default constructor creates invalid promise
auto result = fl::await_top_level(invalid_promise); // Type automatically deduced!
CHECK(!result.ok());
CHECK_EQ(result.error().message, "Invalid promise");
}
SUBCASE("explicit template parameter still works") {
auto promise = fl::promise<int>::resolve(42);
auto result = fl::await_top_level<int>(promise); // Explicit template parameter
CHECK(result.ok());
CHECK_EQ(result.value(), 42);
}
}
TEST_CASE("fl::await_top_level - Asynchronous Completion") {
SUBCASE("await_top_level waits for promise to be resolved") {
auto promise = fl::promise<int>::create();
bool promise_completed = false;
// Simulate async completion in background
// Note: In a real scenario, this would be done by an async system
// For testing, we'll complete it immediately after starting await_top_level
// Complete the promise with a value
promise.complete_with_value(123);
promise_completed = true;
auto result = fl::await_top_level(promise); // Type automatically deduced!
CHECK(promise_completed);
CHECK(result.ok());
CHECK_EQ(result.value(), 123);
}
SUBCASE("await_top_level waits for promise to be rejected") {
auto promise = fl::promise<int>::create();
bool promise_completed = false;
// Complete the promise with an error
promise.complete_with_error(Error("Async error"));
promise_completed = true;
auto result = fl::await_top_level(promise); // Type automatically deduced!
CHECK(promise_completed);
CHECK(!result.ok());
CHECK_EQ(result.error().message, "Async error");
}
}
TEST_CASE("fl::await_top_level - Different Value Types") {
SUBCASE("await_top_level with string type") {
auto promise = fl::promise<fl::string>::resolve(fl::string("Hello, World!"));
auto result = fl::await_top_level(promise); // Type automatically deduced!
CHECK(result.ok());
CHECK_EQ(result.value(), "Hello, World!");
}
SUBCASE("await_top_level with custom struct") {
struct TestData {
int x;
fl::string name;
bool operator==(const TestData& other) const {
return x == other.x && name == other.name;
}
};
TestData expected{42, "test"};
auto promise = fl::promise<TestData>::resolve(expected);
auto result = fl::await_top_level(promise); // Type automatically deduced!
CHECK(result.ok());
CHECK(result.value() == expected);
}
}
TEST_CASE("fl::await_top_level - Error Handling") {
SUBCASE("await_top_level preserves error message") {
fl::string error_msg = "Detailed error message";
auto promise = fl::promise<int>::reject(Error(error_msg));
auto result = fl::await_top_level(promise); // Type automatically deduced!
CHECK(!result.ok());
CHECK_EQ(result.error().message, error_msg);
}
SUBCASE("await_top_level with custom error") {
Error custom_error("Custom error with details");
auto promise = fl::promise<fl::string>::reject(custom_error);
auto result = fl::await_top_level(promise); // Type automatically deduced!
CHECK(!result.ok());
CHECK_EQ(result.error().message, "Custom error with details");
}
}
TEST_CASE("fl::await_top_level - Multiple Awaits") {
SUBCASE("multiple awaits on different promises") {
auto promise1 = fl::promise<int>::resolve(10);
auto promise2 = fl::promise<int>::resolve(20);
auto promise3 = fl::promise<int>::reject(Error("Error in promise 3"));
auto result1 = fl::await_top_level(promise1); // Type automatically deduced!
auto result2 = fl::await_top_level(promise2); // Type automatically deduced!
auto result3 = fl::await_top_level(promise3); // Type automatically deduced!
// Check first result
CHECK(result1.ok());
CHECK_EQ(result1.value(), 10);
// Check second result
CHECK(result2.ok());
CHECK_EQ(result2.value(), 20);
// Check third result (error)
CHECK(!result3.ok());
CHECK_EQ(result3.error().message, "Error in promise 3");
}
SUBCASE("await_top_level same promise multiple times") {
auto promise = fl::promise<int>::resolve(999);
auto result1 = fl::await_top_level(promise); // Type automatically deduced!
auto result2 = fl::await_top_level(promise); // Type automatically deduced!
// Both awaits should return the same result
CHECK(result1.ok());
CHECK(result2.ok());
CHECK_EQ(result1.value(), 999);
CHECK_EQ(result2.value(), 999);
}
}
TEST_CASE("fl::await_top_level - Boolean Conversion and Convenience") {
SUBCASE("boolean conversion operator") {
auto success_promise = fl::promise<int>::resolve(42);
auto success_result = fl::await_top_level(success_promise);
auto error_promise = fl::promise<int>::reject(Error("Error"));
auto error_result = fl::await_top_level(error_promise);
// Test boolean conversion (should work like ok())
CHECK(success_result); // Implicit conversion to bool
CHECK(!error_result); // Implicit conversion to bool
// Equivalent to ok() method
CHECK(success_result.ok());
CHECK(!error_result.ok());
}
SUBCASE("error_message convenience method") {
auto success_promise = fl::promise<int>::resolve(42);
auto success_result = fl::await_top_level(success_promise);
auto error_promise = fl::promise<int>::reject(Error("Test error"));
auto error_result = fl::await_top_level(error_promise);
// Test error_message convenience method
CHECK_EQ(success_result.error_message(), ""); // Empty string for success
CHECK_EQ(error_result.error_message(), "Test error"); // Error message for failure
}
}