klubhaus/klubhaus-doorbell
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
David Gwilliam
2026-02-12 00:45:31 -08:00
commit 5f168f370b
3024 changed files with 804889 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

245
libraries/FastLED/tests/test_set_inlined.cpp Normal file
View File

@@ -0,0 +1,245 @@
#include "test.h"
#include "fl/set.h"
#include "fl/allocator.h"
#include "fl/int.h"
#include "fl/bit_cast.h"
#include <algorithm>
using namespace fl;
TEST_CASE("fl::set_inlined - Basic functionality") {
SUBCASE("Empty set") {
fl::set_inlined<int, 5> set;
CHECK(set.empty());
CHECK(set.size() == 0);
}
SUBCASE("Set has inlined elements") {
fl::set_inlined<int, 5> set;
uptr ptr_begin = fl::ptr_to_int(&set);
uptr ptr_end = ptr_begin + sizeof(set);
set.insert(1);
set.insert(2);
set.insert(3);
set.insert(4);
set.insert(5);
// now make sure that the element addresses are in the right place
for (auto it = set.begin(); it != set.end(); ++it) {
uptr ptr = fl::ptr_to_int(&*it);
CHECK_GE(ptr, ptr_begin);
CHECK_LT(ptr, ptr_end);
}
}
SUBCASE("Single element insertion") {
fl::set_inlined<int, 5> set;
auto result = set.insert(42);
CHECK(result.second); // Insertion successful
CHECK(set.size() == 1);
CHECK(set.contains(42));
}
SUBCASE("Multiple elements within inlined size") {
fl::set_inlined<int, 5> set;
// Insert exactly 5 elements (the inlined size)
CHECK(set.insert(1).second);
CHECK(set.insert(2).second);
CHECK(set.insert(3).second);
CHECK(set.insert(4).second);
CHECK(set.insert(5).second);
CHECK(set.size() == 5);
CHECK(set.contains(1));
CHECK(set.contains(2));
CHECK(set.contains(3));
CHECK(set.contains(4));
CHECK(set.contains(5));
}
SUBCASE("Duplicate insertions") {
fl::set_inlined<int, 3> set;
CHECK(set.insert(10).second);
CHECK(set.insert(20).second);
CHECK_FALSE(set.insert(10).second); // Duplicate should fail
CHECK(set.size() == 2); // Only unique elements
CHECK(set.contains(10));
CHECK(set.contains(20));
}
SUBCASE("Element removal") {
fl::set_inlined<int, 4> set;
set.insert(100);
set.insert(200);
set.insert(300);
CHECK(set.size() == 3);
CHECK(set.erase(200) == 1);
CHECK(set.size() == 2);
CHECK(set.contains(100));
CHECK_FALSE(set.contains(200));
CHECK(set.contains(300));
}
SUBCASE("Clear operation") {
fl::set_inlined<int, 3> set;
set.insert(1);
set.insert(2);
set.insert(3);
CHECK(set.size() == 3);
set.clear();
CHECK(set.empty());
CHECK(set.size() == 0);
}
SUBCASE("Emplace operation") {
fl::set_inlined<int, 3> set;
CHECK(set.emplace(42).second);
CHECK(set.emplace(100).second);
CHECK(set.emplace(200).second);
CHECK(set.size() == 3);
CHECK(set.contains(42));
CHECK(set.contains(100));
CHECK(set.contains(200));
}
SUBCASE("Iterator operations") {
fl::set_inlined<int, 3> set;
set.insert(1);
set.insert(2);
set.insert(3);
// Test iteration
int count = 0;
for (auto it = set.begin(); it != set.end(); ++it) {
count++;
}
CHECK(count == 3);
// Test const iteration
const auto& const_set = set;
count = 0;
for (auto it = const_set.begin(); it != const_set.end(); ++it) {
count++;
}
CHECK(count == 3);
}
SUBCASE("Find operations") {
fl::set_inlined<int, 3> set;
set.insert(10);
set.insert(20);
set.insert(30);
auto it1 = set.find(20);
CHECK(it1 != set.end());
CHECK(*it1 == 20);
auto it2 = set.find(99);
CHECK(it2 == set.end());
}
SUBCASE("Count operations") {
fl::set_inlined<int, 3> set;
set.insert(1);
set.insert(2);
set.insert(3);
CHECK(set.count(1) == 1);
CHECK(set.count(2) == 1);
CHECK(set.count(3) == 1);
CHECK(set.count(99) == 0);
}
SUBCASE("Contains operations") {
fl::set_inlined<int, 3> set;
set.insert(1);
set.insert(2);
set.insert(3);
CHECK(set.contains(1));
CHECK(set.contains(2));
CHECK(set.contains(3));
CHECK_FALSE(set.contains(99));
}
SUBCASE("Custom type with inlined storage") {
struct TestStruct {
int value;
TestStruct(int v = 0) : value(v) {}
bool operator<(const TestStruct& other) const { return value < other.value; }
bool operator==(const TestStruct& other) const { return value == other.value; }
};
fl::set_inlined<TestStruct, 3> set;
CHECK(set.insert(TestStruct(1)).second);
CHECK(set.insert(TestStruct(2)).second);
CHECK(set.insert(TestStruct(3)).second);
CHECK(set.size() == 3);
CHECK(set.contains(TestStruct(1)));
CHECK(set.contains(TestStruct(2)));
CHECK(set.contains(TestStruct(3)));
}
}
TEST_CASE("fl::set_inlined - Exceeding inlined size") {
SUBCASE("Exceeding inlined size") {
fl::set_inlined<int, 2> set;
// Insert within inlined size
CHECK(set.insert(1).second);
CHECK(set.insert(2).second);
// Insert beyond inlined size
CHECK(set.insert(3).second);
CHECK(set.size() == 3);
CHECK(set.contains(1));
CHECK(set.contains(2));
CHECK(set.contains(3));
}
SUBCASE("Heap overflow") {
fl::set_inlined<int, 3> set;
// Insert more than inlined capacity but not too many
for (int i = 0; i < 5; ++i) {
auto result = set.insert(i);
FL_WARN("Insert " << i << ": success=" << result.second << ", size=" << set.size());
}
CHECK(set.size() == 5);
// Debug: print all elements in the set
FL_WARN("Elements in set:");
for (auto it = set.begin(); it != set.end(); ++it) {
FL_WARN(" " << *it);
}
// Verify all elements are present
for (int i = 0; i < 5; ++i) {
bool contains = set.contains(i);
FL_WARN("Contains " << i << ": " << (contains ? "true" : "false"));
CHECK(contains);
}
}
}