1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
// This file is part of the 64k demo project.
// It implements reusable test helpers for GPU effect testing.
// Provides pixel validation and lifecycle testing utilities.
#if !defined(STRIP_ALL) // Test code only - zero size impact on final binary
#include "effect_test_helpers.h"
#include "gpu/effect.h"
#include <cassert>
// ============================================================================
// Pixel Validation Helpers
// ============================================================================
bool validate_pixels(
const std::vector<uint8_t>& pixels,
int width,
int height,
std::function<bool(uint8_t r, uint8_t g, uint8_t b, uint8_t a)> predicate) {
const size_t pixel_count = width * height;
for (size_t i = 0; i < pixel_count; ++i) {
const size_t offset = i * 4; // BGRA8 = 4 bytes/pixel
const uint8_t b = pixels[offset + 0];
const uint8_t g = pixels[offset + 1];
const uint8_t r = pixels[offset + 2];
const uint8_t a = pixels[offset + 3];
if (predicate(r, g, b, a)) {
return true; // At least one pixel matches
}
}
return false; // No pixels matched
}
bool has_rendered_content(const std::vector<uint8_t>& pixels,
int width,
int height) {
return validate_pixels(pixels, width, height,
[](uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
return r > 0 || g > 0 || b > 0;
});
}
bool all_pixels_match_color(const std::vector<uint8_t>& pixels,
int width,
int height,
uint8_t target_r,
uint8_t target_g,
uint8_t target_b,
uint8_t tolerance) {
const size_t pixel_count = width * height;
for (size_t i = 0; i < pixel_count; ++i) {
const size_t offset = i * 4;
const uint8_t b = pixels[offset + 0];
const uint8_t g = pixels[offset + 1];
const uint8_t r = pixels[offset + 2];
const int diff_r = static_cast<int>(r) - static_cast<int>(target_r);
const int diff_g = static_cast<int>(g) - static_cast<int>(target_g);
const int diff_b = static_cast<int>(b) - static_cast<int>(target_b);
if (diff_r * diff_r + diff_g * diff_g + diff_b * diff_b >
tolerance * tolerance) {
return false; // At least one pixel doesn't match
}
}
return true; // All pixels match
}
uint64_t hash_pixels(const std::vector<uint8_t>& pixels) {
// Simple FNV-1a hash
uint64_t hash = 14695981039346656037ULL;
for (const uint8_t byte : pixels) {
hash ^= byte;
hash *= 1099511628211ULL;
}
return hash;
}
// ============================================================================
// Effect Lifecycle Helpers
// ============================================================================
bool test_effect_lifecycle(Effect* effect, MainSequence* main_seq) {
assert(effect && "Effect pointer is null");
assert(main_seq && "MainSequence pointer is null");
// Check initial state
if (effect->is_initialized) {
return false; // Should not be initialized yet
}
// Initialize effect
effect->init(main_seq);
// Check initialized state
if (!effect->is_initialized) {
return false; // Should be initialized now
}
return true; // Lifecycle test passed
}
bool test_effect_render_smoke(Effect* effect) {
assert(effect && "Effect pointer is null");
// Smoke test: Just call render with dummy parameters
// If this doesn't crash, consider it a success
// Note: This requires the effect to be initialized first
if (!effect->is_initialized) {
return false; // Cannot render uninitialized effect
}
// We cannot actually render without a full render pass setup
// This is a placeholder for more sophisticated render testing
// Real render tests should use OffscreenRenderTarget
return true; // Smoke test passed (no crash)
}
#endif /* !defined(STRIP_ALL) */
|
