Debian Codegraph @

libgomp/testsuite/libgomp.c++/target-flex-10.C

raw
1 /* Basic container usage. */
2
3 #include <vector>
4 #include <deque>
5 #include <list>
6 #include <set>
7 #include <map>
8 #if __cplusplus >= 201103L
9 #include <array>
10 #include <forward_list>
11 #include <unordered_set>
12 #include <unordered_map>
13 #endif
14
15 bool vector_test()
16 {
17 bool ok;
18 #pragma omp target map(from: ok)
19 {
20 std::vector<int> vector;
21 ok = vector.empty();
22 }
23 return ok;
24 }
25
26 bool deque_test()
27 {
28 bool ok;
29 #pragma omp target map(from: ok)
30 {
31 std::deque<int> deque;
32 ok = deque.empty();
33 }
34 return ok;
35 }
36
37 bool list_test()
38 {
39 bool ok;
40 #pragma omp target map(from: ok)
41 {
42 std::list<int> list;
43 ok = list.empty();
44 }
45 return ok;
46 }
47
48 bool map_test()
49 {
50 bool ok;
51 #pragma omp target map(from: ok)
52 {
53 std::map<int, int> map;
54 ok = map.empty();
55 }
56 return ok;
57 }
58
59 bool set_test()
60 {
61 bool ok;
62 #pragma omp target map(from: ok)
63 {
64 std::set<int> set;
65 ok = set.empty();
66 }
67 return ok;
68 }
69
70 bool multimap_test()
71 {
72 bool ok;
73 #pragma omp target map(from: ok)
74 {
75 std::multimap<int, int> multimap;
76 ok = multimap.empty();
77 }
78 return ok;
79 }
80
81 bool multiset_test()
82 {
83 bool ok;
84 #pragma omp target map(from: ok)
85 {
86 std::multiset<int, int> multiset;
87 ok = multiset.empty();
88 }
89 return ok;
90 }
91
92 #if __cplusplus >= 201103L
93
94 bool array_test()
95 {
96 static constexpr std::size_t array_size = 42;
97 bool ok;
98 #pragma omp target map(from: ok)
99 {
100 std::array<int, array_size> array{};
101 ok = array[0] == 0
102 && array[array_size - 1] == 0;
103 }
104 return ok;
105 }
106
107 bool forward_list_test()
108 {
109 bool ok;
110 #pragma omp target map(from: ok)
111 {
112 std::forward_list<int> forward_list;
113 ok = forward_list.empty();
114 }
115 return ok;
116 }
117
118 bool unordered_map_test()
119 {
120 bool ok;
121 #pragma omp target map(from: ok)
122 {
123 std::unordered_map<int, int> unordered_map;
124 ok = unordered_map.empty();
125 }
126 return ok;
127 }
128
129 bool unordered_set_test()
130 {
131 bool ok;
132 #pragma omp target map(from: ok)
133 {
134 std::unordered_set<int> unordered_set;
135 ok = unordered_set.empty();
136 }
137 return ok;
138 }
139
140 bool unordered_multimap_test()
141 {
142
143 bool ok;
144 #pragma omp target map(from: ok)
145 {
146 std::unordered_multimap<int, int> unordered_multimap;
147 ok = unordered_multimap.empty();
148 }
149 return ok;
150 }
151
152 bool unordered_multiset_test()
153 {
154
155 bool ok;
156 #pragma omp target map(from: ok)
157 {
158 std::unordered_multiset<int> unordered_multiset;
159 ok = unordered_multiset.empty();
160 }
161 return ok;
162 }
163
164 #else
165 bool array_test() { return true; }
166 bool forward_list_test() { return true; }
167 bool unordered_map_test() { return true; }
168 bool unordered_set_test() { return true; }
169 bool unordered_multimap_test() { return true; }
170 bool unordered_multiset_test() { return true; }
171 #endif
172
173 int main()
174 {
175 const bool vec_res = vector_test();
176 __builtin_printf("vector : %s\n", vec_res ? "PASS" : "FAIL");
177 const bool deque_res = deque_test();
178 __builtin_printf("deque : %s\n", deque_res ? "PASS" : "FAIL");
179 const bool list_res = list_test();
180 __builtin_printf("list : %s\n", list_res ? "PASS" : "FAIL");
181 const bool map_res = map_test();
182 __builtin_printf("map : %s\n", map_res ? "PASS" : "FAIL");
183 const bool set_res = set_test();
184 __builtin_printf("set : %s\n", set_res ? "PASS" : "FAIL");
185 const bool multimap_res = multimap_test();
186 __builtin_printf("multimap : %s\n", multimap_res ? "PASS" : "FAIL");
187 const bool multiset_res = multiset_test();
188 __builtin_printf("multiset : %s\n", multiset_res ? "PASS" : "FAIL");
189 const bool array_res = array_test();
190 __builtin_printf("array : %s\n", array_res ? "PASS" : "FAIL");
191 const bool forward_list_res = forward_list_test();
192 __builtin_printf("forward_list : %s\n", forward_list_res ? "PASS" : "FAIL");
193 const bool unordered_map_res = unordered_map_test();
194 __builtin_printf("unordered_map : %s\n", unordered_map_res ? "PASS" : "FAIL");
195 const bool unordered_set_res = unordered_set_test();
196 __builtin_printf("unordered_set : %s\n", unordered_set_res ? "PASS" : "FAIL");
197 const bool unordered_multimap_res = unordered_multimap_test();
198 __builtin_printf("unordered_multimap: %s\n", unordered_multimap_res ? "PASS" : "FAIL");
199 const bool unordered_multiset_res = unordered_multiset_test();
200 __builtin_printf("unordered_multiset: %s\n", unordered_multiset_res ? "PASS" : "FAIL");
201 const bool ok = vec_res
202 && deque_res
203 && list_res
204 && map_res
205 && set_res
206 && multimap_res
207 && multiset_res
208 && array_res
209 && forward_list_res
210 && unordered_map_res
211 && unordered_set_res
212 && unordered_multimap_res
213 && unordered_multiset_res;
214 return ok ? 0 : 1;
215 }