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
|
/* Global test failure counter.
Copyright (C) 2016-2021 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#include <support/check.h>
#include <support/support.h>
#include <support/test-driver.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
/* This structure keeps track of test failures. The counter is
incremented on each failure. The failed member is set to true if a
failure is detected, so that even if the counter wraps around to
zero, the failure of a test can be detected.
The init constructor function below puts *state on a shared
annonymous mapping, so that failure reports from subprocesses
propagate to the parent process. */
struct test_failures
{
unsigned int counter;
unsigned int failed;
};
static struct test_failures *state;
static __attribute__ ((constructor)) void
init (void)
{
void *ptr = mmap (NULL, sizeof (*state), PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_SHARED, -1, 0);
if (ptr == MAP_FAILED)
{
printf ("error: could not map %zu bytes: %m\n", sizeof (*state));
exit (1);
}
/* Zero-initialization of the struct is sufficient. */
state = ptr;
}
void
support_record_failure (void)
{
if (state == NULL)
{
write_message
("error: support_record_failure called without initialization\n");
_exit (1);
}
/* Relaxed MO is sufficient because we are only interested in the
values themselves, in isolation. */
__atomic_store_n (&state->failed, 1, __ATOMIC_RELEASE);
__atomic_add_fetch (&state->counter, 1, __ATOMIC_RELEASE);
}
int
support_report_failure (int status)
{
if (state == NULL)
{
write_message
("error: support_report_failure called without initialization\n");
return 1;
}
/* Relaxed MO is sufficient because acquire test result reporting
assumes that exiting from the main thread happens before the
error reporting via support_record_failure, which requires some
form of external synchronization. */
bool failed = __atomic_load_n (&state->failed, __ATOMIC_RELAXED);
if (failed)
printf ("error: %u test failures\n",
__atomic_load_n (&state->counter, __ATOMIC_RELAXED));
if ((status == 0 || status == EXIT_UNSUPPORTED) && failed)
/* If we have a recorded failure, it overrides a non-failure
report from the test function. */
status = 1;
return status;
}
void
support_record_failure_reset (void)
{
/* Only used for testing the test framework, with external
synchronization, but use release MO for consistency. */
__atomic_store_n (&state->failed, 0, __ATOMIC_RELAXED);
__atomic_add_fetch (&state->counter, 0, __ATOMIC_RELAXED);
}
int
support_record_failure_is_failed (void)
{
/* Relaxed MO is sufficient because we need (blocking) external
synchronization for reliable test error reporting anyway. */
return __atomic_load_n (&state->failed, __ATOMIC_RELAXED);
}
|
