← Back to branch summary

~ubuntu-branches/ubuntu/quantal/libgc/quantal

« back to all changes in this revision

Viewing changes to libatomic_ops-1.2/tests/test_atomic.template

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Egger
  • Date: 2011-02-19 12:19:56 UTC
  • mfrom: (1.3.2 upstream) (0.1.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: james.westby@ubuntu.com-20110219121956-67rb69xlt5nud3v2
Tags: 1:7.1-5
Upload to unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
libatomic_ops-1.2/tests/test_atomic.template
 
1
/*
 
2
 * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 
3
 *
 
4
 * This file is covered by the GNU general public license, version 2.
 
5
 * see doc/COPYING for details.
 
6
 */
 
7
 
 
8
/* Some basic sanity tests.  These do not test the barrier semantics. */
 
9
 
 
10
#undef TA_assert
 
11
#define TA_assert(e) \
 
12
  if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: XX)\n", \
 
13
                    __FILE__, __LINE__), exit(1); }
 
14
 
 
15
#undef MISSING
 
16
#define MISSING(name) \
 
17
  fprintf(stderr, "Missing: %s\n", #name "XX")
 
18
 
 
19
void test_atomicXX(void)
 
20
{
 
21
  AO_t x;
 
22
  unsigned char b;
 
23
  unsigned short s;
 
24
  unsigned int zz;
 
25
# if defined(AO_HAVE_test_and_setXX)
 
26
    AO_TS_t z = AO_TS_INITIALIZER;
 
27
# endif
 
28
# if defined(AO_HAVE_double_t)
 
29
    AO_double_t w;
 
30
    w.AO_val1 = 0;
 
31
    w.AO_val2 = 0;
 
32
# endif
 
33
 
 
34
# if defined(AO_HAVE_nopXX)
 
35
    AO_nopXX();
 
36
# else
 
37
    MISSING(AO_nop);
 
38
# endif
 
39
# if defined(AO_HAVE_storeXX)
 
40
    AO_storeXX(&x, 13);
 
41
    TA_assert (x == 13);
 
42
# else
 
43
    MISSING(AO_store);
 
44
    x = 13;
 
45
# endif
 
46
# if defined(AO_HAVE_loadXX)
 
47
    TA_assert(AO_loadXX(&x) == 13);
 
48
# else
 
49
    MISSING(AO_load);
 
50
# endif
 
51
# if defined(AO_HAVE_test_and_setXX)
 
52
    assert(AO_test_and_setXX(&z) == AO_TS_CLEAR);
 
53
    assert(AO_test_and_setXX(&z) == AO_TS_SET);
 
54
    assert(AO_test_and_setXX(&z) == AO_TS_SET);
 
55
    AO_CLEAR(&z);
 
56
# else
 
57
    MISSING(AO_test_and_set);
 
58
# endif
 
59
# if defined(AO_HAVE_fetch_and_addXX)
 
60
    TA_assert(AO_fetch_and_addXX(&x, 42) == 13);
 
61
    TA_assert(AO_fetch_and_addXX(&x, -42) == 55);
 
62
# else
 
63
    MISSING(AO_fetch_and_add);
 
64
# endif
 
65
# if defined(AO_HAVE_fetch_and_add1XX)
 
66
    TA_assert(AO_fetch_and_add1XX(&x) == 13);
 
67
# else
 
68
    MISSING(AO_fetch_and_add1);
 
69
    ++x;
 
70
# endif
 
71
# if defined(AO_HAVE_fetch_and_sub1XX)
 
72
    TA_assert(AO_fetch_and_sub1XX(&x) == 14);
 
73
# else
 
74
    MISSING(AO_fetch_and_sub1);
 
75
    --x;
 
76
# endif
 
77
# if defined(AO_HAVE_short_storeXX)
 
78
    AO_short_storeXX(&s, 13);
 
79
# else
 
80
    MISSING(AO_short_store);
 
81
    s = 13;
 
82
# endif
 
83
# if defined(AO_HAVE_short_loadXX)
 
84
    TA_assert(AO_short_load(&s) == 13);
 
85
# else
 
86
    MISSING(AO_short_load);
 
87
# endif
 
88
# if defined(AO_HAVE_short_fetch_and_addXX)
 
89
    TA_assert(AO_short_fetch_and_addXX(&s, 42) == 13);
 
90
    TA_assert(AO_short_fetch_and_addXX(&s, -42) == 55);
 
91
# else
 
92
    MISSING(AO_short_fetch_and_add);
 
93
# endif
 
94
# if defined(AO_HAVE_short_fetch_and_add1XX)
 
95
    TA_assert(AO_short_fetch_and_add1XX(&s) == 13);
 
96
# else
 
97
    MISSING(AO_short_fetch_and_add1);
 
98
    ++s;
 
99
# endif
 
100
# if defined(AO_HAVE_short_fetch_and_sub1XX)
 
101
    TA_assert(AO_short_fetch_and_sub1XX(&s) == 14);
 
102
# else
 
103
    MISSING(AO_short_fetch_and_sub1);
 
104
    --s;
 
105
# endif
 
106
# if defined(AO_HAVE_char_storeXX)
 
107
    AO_char_storeXX(&b, 13);
 
108
# else
 
109
    MISSING(AO_char_store);
 
110
    b = 13;
 
111
# endif
 
112
# if defined(AO_HAVE_char_loadXX)
 
113
    TA_assert(AO_char_load(&b) == 13);
 
114
# else
 
115
    MISSING(AO_char_load);
 
116
# endif
 
117
# if defined(AO_HAVE_char_fetch_and_addXX)
 
118
    TA_assert(AO_char_fetch_and_addXX(&b, 42) == 13);
 
119
    TA_assert(AO_char_fetch_and_addXX(&b, -42) == 55);
 
120
# else
 
121
    MISSING(AO_char_fetch_and_add);
 
122
# endif
 
123
# if defined(AO_HAVE_char_fetch_and_add1XX)
 
124
    TA_assert(AO_char_fetch_and_add1XX(&b) == 13);
 
125
# else
 
126
    MISSING(AO_char_fetch_and_add1);
 
127
    ++b;
 
128
# endif
 
129
# if defined(AO_HAVE_char_fetch_and_sub1XX)
 
130
    TA_assert(AO_char_fetch_and_sub1XX(&b) == 14);
 
131
# else
 
132
    MISSING(AO_char_fetch_and_sub1);
 
133
    --b;
 
134
# endif
 
135
# if defined(AO_HAVE_int_storeXX)
 
136
    AO_int_storeXX(&zz, 13);
 
137
# else
 
138
    MISSING(AO_int_store);
 
139
    zz = 13;
 
140
# endif
 
141
# if defined(AO_HAVE_int_loadXX)
 
142
    TA_assert(AO_int_load(&zz) == 13);
 
143
# else
 
144
    MISSING(AO_int_load);
 
145
# endif
 
146
# if defined(AO_HAVE_int_fetch_and_addXX)
 
147
    TA_assert(AO_int_fetch_and_addXX(&zz, 42) == 13);
 
148
    TA_assert(AO_int_fetch_and_addXX(&zz, -42) == 55);
 
149
# else
 
150
    MISSING(AO_int_fetch_and_add);
 
151
# endif
 
152
# if defined(AO_HAVE_int_fetch_and_add1XX)
 
153
    TA_assert(AO_int_fetch_and_add1XX(&zz) == 13);
 
154
# else
 
155
    MISSING(AO_int_fetch_and_add1);
 
156
    ++zz;
 
157
# endif
 
158
# if defined(AO_HAVE_int_fetch_and_sub1XX)
 
159
    TA_assert(AO_int_fetch_and_sub1XX(&zz) == 14);
 
160
# else
 
161
    MISSING(AO_int_fetch_and_sub1);
 
162
    --zz;
 
163
# endif
 
164
# if defined(AO_HAVE_compare_and_swapXX)
 
165
    TA_assert(!AO_compare_and_swapXX(&x, 14, 42));
 
166
    TA_assert(x == 13);
 
167
    TA_assert(AO_compare_and_swapXX(&x, 13, 42));
 
168
    TA_assert(x == 42);
 
169
# else
 
170
    MISSING(AO_compare_and_swap);
 
171
# endif
 
172
# if defined(AO_HAVE_orXX)
 
173
    AO_orXX(&x, 66);
 
174
    TA_assert(x == 106);
 
175
# else
 
176
    MISSING(AO_or);
 
177
    x |= 34;
 
178
# endif
 
179
# if defined(AO_HAVE_compare_double_and_swap_doubleXX)
 
180
    TA_assert(!AO_compare_double_and_swap_doubleXX(&w, 17, 42, 12, 13));
 
181
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
182
    TA_assert(AO_compare_double_and_swap_doubleXX(&w, 0, 0, 12, 13));
 
183
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
184
    TA_assert(AO_compare_double_and_swap_doubleXX(&w, 12, 13, 17, 42));
 
185
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
186
    w.AO_val1 = 0; w.AO_val2 = 0;
 
187
# else
 
188
    MISSING(AO_compare_double_and_swap_double);
 
189
# endif
 
190
# if defined(AO_HAVE_compare_and_swap_doubleXX)
 
191
    TA_assert(!AO_compare_and_swap_doubleXX(&w, 17, 12, 13));
 
192
    TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 
193
    TA_assert(AO_compare_and_swap_doubleXX(&w, 0, 12, 13));
 
194
    TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 
195
    TA_assert(AO_compare_and_swap_doubleXX(&w, 12, 17, 42));
 
196
    TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 
197
# else
 
198
    MISSING(AO_compare_and_swap_double);
 
199
# endif
 
200
}
 
201
 
 
202
 
 
203