Arcane  v3.15.3.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
TestCollections.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7
8#include <gtest/gtest.h>
9
10#include "arcane/utils/List.h"
11#include "arcane/utils/String.h"
12#include "arcane/utils/SmallArray.h"
13#include "arcane/utils/FixedArray.h"
14
15#ifdef ARCANE_HAS_CXX20
16#include <ranges>
17#endif
18
19/*---------------------------------------------------------------------------*/
20/*---------------------------------------------------------------------------*/
21
22using namespace Arcane;
23
24TEST(Collections, Basic)
25{
26 std::cout << "TEST_Collection Basic\n";
27 std::cout << "STRUCT_ARRAY=" << sizeof(UniqueArray<Int32>) << "\n";
28
29 StringList string_list;
30 String str1 = "TotoTiti";
31 String str2 = "Tata";
32 String str3 = "Hello";
33 String str4 = "MyStringToTest";
34
35 string_list.add(str1);
36 ASSERT_EQ(string_list.count(), 1);
37
38 string_list.add(str2);
39 ASSERT_EQ(string_list.count(), 2);
40
41 string_list.add(str3);
42 ASSERT_EQ(string_list.count(), 3);
43
44 ASSERT_TRUE(string_list.contains("Tata"));
45 ASSERT_FALSE(string_list.contains("NotTata"));
46 ASSERT_EQ(string_list[0], str1);
47 ASSERT_EQ(string_list[1], "Tata");
48 ASSERT_EQ(string_list[2], str3);
49
50 string_list.remove("Tata");
51 ASSERT_EQ(string_list.count(), 2);
52 ASSERT_EQ(string_list[0], str1);
53 ASSERT_EQ(string_list[1], str3);
54
55 string_list.clear();
56 ASSERT_EQ(string_list.count(), 0);
57
58 string_list.add(str4);
59 ASSERT_EQ(string_list.count(), 1);
60 string_list.add(str2);
61 ASSERT_EQ(string_list.count(), 2);
62 string_list.add(str1);
63 ASSERT_EQ(string_list.count(), 3);
64
65 ASSERT_TRUE(string_list.contains("Tata"));
66 ASSERT_FALSE(string_list.contains("NotTata"));
67 ASSERT_TRUE(string_list.contains(str2));
68 ASSERT_FALSE(string_list.contains(str3));
69 ASSERT_TRUE(string_list.contains(str1));
70}
71
72void
73_checkSmallArrayValues(Span<const Int32> view)
74{
75 for( Int64 i=0, n=view.size(); i<n; ++i )
76 ASSERT_EQ(view[i],i+1);
77}
78
79void
80_checkSmallArrayValues(Span<const Int32> view1,Span<const Int32> view2)
81{
82 Int64 n1 = view1.size();
83 Int64 n2 = view2.size();
84 ASSERT_EQ(n1,n2);
85 for( Int64 i=0; i<n1; ++i )
86 ASSERT_EQ(view1[i],view2[i]);
87}
88
89TEST(Collections,SmallArray)
90{
91 {
92 constexpr int N = 934;
93 char buf[N];
94 impl::StackMemoryAllocator b(buf,N);
95 ASSERT_EQ(b.guarantedAlignment({}),0);
96 }
97 {
98 SmallArray<Int32,400> buf1;
99 for( Int32 i=0; i<200; ++i )
100 buf1.add(i+1);
101 ASSERT_EQ(buf1.size(),200);
102 _checkSmallArrayValues(buf1);
103
104 buf1.resize(50);
105 buf1.shrink();
106 ASSERT_EQ(buf1.size(),50);
107 _checkSmallArrayValues(buf1);
108
109 for( Int32 i=0; i<200; ++i )
110 buf1.add(50+i+1);
111 ASSERT_EQ(buf1.size(),250);
112 _checkSmallArrayValues(buf1);
113 }
114 for( int z=1; z<10; ++z ) {
115 UniqueArray<Int32> ref_buf(250*z);
116 for(Int32 i=0, n=ref_buf.size(); i<n; ++i )
117 ref_buf[i] = (i+1)*2;
118
119 UniqueArray<Int32> ref_buf2(100*z*z);
120 for(Int32 i=0, n=ref_buf2.size(); i<n; ++i )
121 ref_buf2[i] = (i+13)*3;
122
123 SmallArray<Int32,1024> buf2(ref_buf);
124 _checkSmallArrayValues(buf2,ref_buf);
125 SmallArray<Int32,1024> buf3(ref_buf.span());
126 _checkSmallArrayValues(buf3,ref_buf);
127 SmallArray<Int32,1024> buf4(ref_buf.constSpan());
128 _checkSmallArrayValues(buf4,ref_buf);
129 SmallArray<Int32,1024> buf5(ref_buf.view());
130 _checkSmallArrayValues(buf5,ref_buf);
131 SmallArray<Int32,1024> buf6(ref_buf.constView());
132 _checkSmallArrayValues(buf6,ref_buf);
133
134 buf2 = ref_buf2;
135 _checkSmallArrayValues(buf2,ref_buf2);
136 buf3 = ref_buf2.span();
137 _checkSmallArrayValues(buf3,ref_buf2);
138 buf4 = ref_buf2.constSpan();
139 _checkSmallArrayValues(buf4,ref_buf2);
140 buf5 = ref_buf2.view();
141 _checkSmallArrayValues(buf5,ref_buf2);
142 buf6 = ref_buf2.constView();
143 _checkSmallArrayValues(buf6,ref_buf2);
144 }
145 {
146 for( int z=1; z<10; ++z ) {
147 Int32 n = 5+(z*100);
148 SmallArray<Int32> buf3(n);
149 ASSERT_EQ(buf3.size(),n);
150 for(Int32 i=0; i<n; ++i )
151 buf3[i] = (i*22)+1;
152 for(Int32 i=0; i<n; ++i )
153 ASSERT_EQ(buf3[i],((i*22)+1));
154 }
155 }
156 {
157 std::cout << "Test initializer_list 1\n";
158 SmallArray<Int32,20> buf = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25,
159 27, 29, 31, 33, 35, 37, 39, 41 };
160 Int32 n = 21;
161 ASSERT_EQ(buf.size(),n);
162 for(Int32 i=0; i<n; ++i )
163 ASSERT_EQ(buf[i],((i*2)+1));
164 }
165 {
166 std::cout << "Test initializer_list 2\n";
167 SmallArray<Int32,100> buf = { 1, 3, 5, 7, 9, 11 };
168 Int32 n = 6;
169 ASSERT_EQ(buf.size(),n);
170 for(Int32 i=0; i<n; ++i )
171 ASSERT_EQ(buf[i],((i*2)+1));
172 }
173 {
174 size_t s1 = 513;
175 SmallArray<Int32> buf1(s1);
176 ASSERT_EQ(buf1.size(),s1);
177
178 Int64 s2 = 217;
179 SmallArray<Int32> buf2(s2);
180 ASSERT_EQ(buf2.size(),s2);
181 }
182}
183
184/*---------------------------------------------------------------------------*/
185/*---------------------------------------------------------------------------*/
186
187TEST(Collections, FixedArray)
188{
189#ifdef ARCANE_HAS_CXX20
190 static_assert(std::ranges::contiguous_range<FixedArray<Int32, 2>>);
191#endif
192
193 {
194 FixedArray<Int32, 0> empty_array;
195 ASSERT_EQ(empty_array.size(), 0);
196 ASSERT_EQ(empty_array.span().size(), 0);
197 }
198
199 {
200 static constexpr Int32 Size = 4;
201 FixedArray<Int32, Size> array1;
202 const FixedArray<Int32, Size>& const_array1(array1);
203 ASSERT_EQ(array1.size(), Size);
204 ASSERT_EQ(array1.span().size(), Size);
205 ASSERT_EQ(array1.view().size(), Size);
206 ASSERT_EQ(const_array1.span().size(), Size);
207 ASSERT_EQ(const_array1.view().size(), Size);
208 for (Int32 i = 0; i < Size; ++i) {
209 ASSERT_EQ(array1[i], 0);
210 ASSERT_EQ(array1.span()[i], 0);
211 ASSERT_EQ(array1.view()[i], 0);
212 ASSERT_EQ(const_array1.view()[i], 0);
213 }
214
215 array1[0] = 3;
216 array1[1] = 5;
217 array1[2] = -1;
218 array1[3] = 8;
219 ASSERT_EQ(array1[0], 3);
220 ASSERT_EQ(array1[1], 5);
221 ASSERT_EQ(const_array1[1], 5);
222 std::cout << "V[2]=" << array1[2] << "\n";
223 {
224 auto iter = array1.begin();
225 ASSERT_EQ(*iter, 3);
226 ASSERT_EQ(*iter, *const_array1.begin());
227 ++iter;
228 ASSERT_EQ(*iter, 5);
229 ++iter;
230 ASSERT_EQ(*iter, -1);
231 ++iter;
232 ASSERT_EQ(*iter, 8);
233 ++iter;
234 ASSERT_EQ(iter, array1.end());
235 ASSERT_EQ(iter, const_array1.end());
236 }
237 }
238 {
239 FixedArray<Int32, 2> v({ 1, 2 });
240 ASSERT_EQ(v[0], 1);
241 ASSERT_EQ(v[1], 2);
242 }
243 {
244 FixedArray<Int32, 2> v({ 3 });
245 ASSERT_EQ(v[0], 3);
246 ASSERT_EQ(v[1], 0);
247 }
248 {
249 UniqueArray<Int32> a1;
250 a1.add(3);
251 a1.add(5);
252 UniqueArray<Int32> a2;
253 a2.add(27);
254 a2.add(32);
255 a2.add(21);
256 FixedArray<UniqueArray<Int32>, 2> v({ a1, a2 });
257 ASSERT_EQ(v[0].size(), 2);
258 ASSERT_EQ(v[0][1], 5);
259 ASSERT_EQ(v[0][1], 5);
260 ASSERT_EQ(v[1].size(), 3);
261 ASSERT_EQ(v[1][0], 27);
262 ASSERT_EQ(v[1][1], 32);
263 ASSERT_EQ(v[1][2], 21);
264 FixedArray<UniqueArray<Int32>, 2> v2({ a1 });
265 v2 = { a2 };
266 ASSERT_EQ(v2[0].size(), 3);
267 ASSERT_EQ(v2[0][0], 27);
268 ASSERT_EQ(v2[0][1], 32);
269 ASSERT_EQ(v2[0][2], 21);
270 ASSERT_EQ(v2[1].size(), 0);
271 }
272}
273
274/*---------------------------------------------------------------------------*/
275/*---------------------------------------------------------------------------*/
276
277namespace Arcane
278{
279template class List<String>;
280template class ListImplBase<String>;
281template class ListImplT<String>;
282template class Collection<String>;
283template class CollectionImplT<String>;
284
285template class SmallArray<Int32>;
286template class FixedArray<Int32,3>;
287template class FixedArray<double, 21>;
288}
289
290/*---------------------------------------------------------------------------*/
291/*---------------------------------------------------------------------------*/
ASSERT_FALSE
#define ASSERT_FALSE(condition)
Vérifie que condition est faux.
Definition Assertion.h:138
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Vérifie que condition est vrai.
Definition Assertion.h:126
Arcane::FixedArray
Tableau 1D de taille fixe.
Definition FixedArray.h:45
Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:149
Arcane::SmallArray
Tableau 1D de données avec buffer pré-alloué sur la pile.
Definition SmallArray.h:89
Arcane::impl::StackMemoryAllocator
Allocateur avec buffer pré-alloué.
Definition SmallArray.h:40
Arccore::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36