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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
#include <assert.h>
#include <ck_ec.h>
#include "fuzz_harness.h"
static int gettime(const struct ck_ec_ops *, struct timespec *out);
static void wake32(const struct ck_ec_ops *, const uint32_t *);
static void wait32(const struct ck_ec_wait_state *, const uint32_t *,
uint32_t, const struct timespec *);
static void wake64(const struct ck_ec_ops *, const uint64_t *);
static void wait64(const struct ck_ec_wait_state *, const uint64_t *,
uint64_t, const struct timespec *);
static const struct ck_ec_ops test_ops = {
.gettime = gettime,
.wait32 = wait32,
.wait64 = wait64,
.wake32 = wake32,
.wake64 = wake64
};
static const struct ck_ec_mode modes[] = {
{
.single_producer = true,
.ops = &test_ops
},
{
.single_producer = false,
.ops = &test_ops
},
};
static int gettime(const struct ck_ec_ops *ops, struct timespec *out)
{
(void)out;
assert(ops == &test_ops);
return -1;
}
static void wait32(const struct ck_ec_wait_state *wait_state,
const uint32_t *addr, uint32_t expected,
const struct timespec *deadline)
{
(void)addr;
(void)expected;
(void)deadline;
assert(wait_state->ops == &test_ops);
return;
}
static void wait64(const struct ck_ec_wait_state *wait_state,
const uint64_t *addr, uint64_t expected,
const struct timespec *deadline)
{
(void)addr;
(void)expected;
(void)deadline;
assert(wait_state->ops == &test_ops);
return;
}
static void wake32(const struct ck_ec_ops *ops, const uint32_t *addr)
{
(void)addr;
assert(ops == &test_ops);
return;
}
static void wake64(const struct ck_ec_ops *ops, const uint64_t *addr)
{
(void)addr;
assert(ops == &test_ops);
return;
}
/*
* Check that adding a value correctly updates the counter, and that
* incrementing after that also works.
*/
struct example {
uint64_t value[2];
};
static const struct example examples[] = {
{ { 0, 0 } },
{ { 1, 2 } },
{ { 0, INT32_MAX - 2 } },
{ { 0, INT32_MAX - 1 } },
{ { 0, INT32_MAX } },
{ { 0, INT64_MAX - 2 } },
{ { 0, INT64_MAX - 1 } },
{ { 0, INT64_MAX } },
};
static inline int test_value(const struct example *example)
{
for (size_t i = 0; i < 2; i++) {
const struct ck_ec_mode *mode = &modes[i];
const uint32_t value0 = example->value[0] & INT32_MAX;
const uint32_t value1 = example->value[1] & INT32_MAX;
struct ck_ec32 ec;
ck_ec32_init(&ec, 0);
assert(ck_ec32_value(&ec) == 0);
ck_ec32_add(&ec, mode, value0);
assert(ck_ec32_value(&ec) == value0);
ck_ec32_add(&ec, mode, value1);
assert(ck_ec32_value(&ec) ==
((value0 + value1) & INT32_MAX));
ck_ec32_inc(&ec, mode);
assert(ck_ec32_value(&ec) ==
((value0 + value1 + 1) & INT32_MAX));
}
#ifdef CK_F_EC64
for (size_t i = 0; i < 2; i++) {
const struct ck_ec_mode *mode = &modes[i];
const uint64_t value0 = example->value[0] & INT64_MAX;
const uint64_t value1 = example->value[1] & INT64_MAX;
struct ck_ec64 ec;
ck_ec64_init(&ec, 0);
assert(ck_ec64_value(&ec) == 0);
ck_ec64_add(&ec, mode, value0);
assert(ck_ec64_value(&ec) == value0);
ck_ec64_add(&ec, mode, value1);
assert(ck_ec64_value(&ec) ==
((value0 + value1) & INT64_MAX));
ck_ec64_inc(&ec, mode);
assert(ck_ec64_value(&ec) ==
((value0 + value1 + 1) & INT64_MAX));
}
#endif /* CK_F_EC64 */
return 0;
}
TEST(test_value, examples)
|
