BlackMark/CoopAllTheThings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Apply clang-format across the whole tree

Browse Source 
Run clang-format (the repo's .clang-format: LLVM base, 120 cols, tabs,
Allman functions) over every source file so the tree is formatter-clean.
Whitespace only -- no behavior change; full x64 + x86 suites pass.

Also set SortIncludes: false in .clang-format. Windows include order is
load-bearing (windows.h must precede tlhelp32.h / mmreg.h / xinput.h /
dinput.h; winsock2.h must precede windows.h), and the default
alphabetical sort reorders tlhelp32.h ahead of windows.h -- a build
break. Leaving order alone keeps the manual, correct grouping.
This commit is contained in:
BlackMark
2026-07-12 11:52:53 +02:00
parent c684a15fb9
commit 30eccf749d
155 changed files with 3333 additions and 6171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
tests/mkb_ring_test.cpp
View File

@@ -5,13 +5,11 @@
using namespace coop;
namespace
{
namespace {
int g_failures = 0;
void check(bool cond, const char* what)
{
if (!cond)
{
if (!cond) {
std::printf("FAIL: %s\n", what);
++g_failures;
}
@@ -27,13 +25,11 @@ int main()
check(!pop_mkb_event(ring, out), "pop on empty ring returns false");
// Push then pop returns the same event, FIFO.
for (std::uint32_t i = 0; i < 10; ++i)
{
for (std::uint32_t i = 0; i < 10; ++i) {
MkbEvent ev{Mkb_KeyDown, i, static_cast<int>(i) * 2, static_cast<int>(i) * 3};
check(push_mkb_event(ring, ev), "push succeeds with room");
}
for (std::uint32_t i = 0; i < 10; ++i)
{
for (std::uint32_t i = 0; i < 10; ++i) {
check(pop_mkb_event(ring, out), "pop succeeds with data");
check(out.code == i && out.x == static_cast<int>(i) * 2 && out.y == static_cast<int>(i) * 3,
"popped event matches pushed (FIFO)");
@@ -41,39 +37,32 @@ int main()
check(!pop_mkb_event(ring, out), "ring empty again after draining");
// Fill to capacity, then one more push is dropped.
for (std::uint32_t i = 0; i < kMkbQueueSize; ++i)
{
for (std::uint32_t i = 0; i < kMkbQueueSize; ++i) {
check(push_mkb_event(ring, MkbEvent{Mkb_Char, i, 0, 0}), "push fills to capacity");
}
check(!push_mkb_event(ring, MkbEvent{Mkb_Char, 999, 0, 0}), "push on full ring is dropped");
// Drain and verify order survived a full buffer.
for (std::uint32_t i = 0; i < kMkbQueueSize; ++i)
{
for (std::uint32_t i = 0; i < kMkbQueueSize; ++i) {
check(pop_mkb_event(ring, out) && out.code == i, "full-buffer drain is in order");
}
// Wrap-around: indices are free-running, so many cycles must keep working.
std::uint32_t produced = 0, consumed = 0;
for (int cycle = 0; cycle < 1000; ++cycle)
{
for (int k = 0; k < 50; ++k)
{
if (push_mkb_event(ring, MkbEvent{Mkb_MouseDown, produced, 0, 0}))
{
for (int cycle = 0; cycle < 1000; ++cycle) {
for (int k = 0; k < 50; ++k) {
if (push_mkb_event(ring, MkbEvent{Mkb_MouseDown, produced, 0, 0})) {
++produced;
}
}
while (pop_mkb_event(ring, out))
{
while (pop_mkb_event(ring, out)) {
check(out.code == consumed, "wrap-around preserves FIFO order");
++consumed;
}
}
check(produced == consumed, "all wrap-around events consumed");
if (g_failures == 0)
{
if (g_failures == 0) {
std::printf("PASS: mkb_ring_test\n");
return 0;
}