Arcane  v3.16.2.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#include "arcane/utils/MultiArray2.h"
15
16#ifdef ARCANE_HAS_CXX20
17#include <ranges>
18#endif
19
20/*---------------------------------------------------------------------------*/
21/*---------------------------------------------------------------------------*/
22
23using namespace Arcane;
24
25TEST(Collections, Basic)
26{
27 std::cout << "TEST_Collection Basic\n";
28 std::cout << "STRUCT_ARRAY=" << sizeof(UniqueArray<Int32>) << "\n";
29
30 StringList string_list;
31 String str1 = "TotoTiti";
32 String str2 = "Tata";
33 String str3 = "Hello";
34 String str4 = "MyStringToTest";
35
36 string_list.add(str1);
37 ASSERT_EQ(string_list.count(), 1);
38
39 string_list.add(str2);
40 ASSERT_EQ(string_list.count(), 2);
41
42 string_list.add(str3);
43 ASSERT_EQ(string_list.count(), 3);
44
45 ASSERT_TRUE(string_list.contains("Tata"));
46 ASSERT_FALSE(string_list.contains("NotTata"));
47 ASSERT_EQ(string_list[0], str1);
48 ASSERT_EQ(string_list[1], "Tata");
49 ASSERT_EQ(string_list[2], str3);
50
51 string_list.remove("Tata");
52 ASSERT_EQ(string_list.count(), 2);
53 ASSERT_EQ(string_list[0], str1);
54 ASSERT_EQ(string_list[1], str3);
55
56 string_list.clear();
57 ASSERT_EQ(string_list.count(), 0);
58
59 string_list.add(str4);
60 ASSERT_EQ(string_list.count(), 1);
61 string_list.add(str2);
62 ASSERT_EQ(string_list.count(), 2);
63 string_list.add(str1);
64 ASSERT_EQ(string_list.count(), 3);
65
66 ASSERT_TRUE(string_list.contains("Tata"));
67 ASSERT_FALSE(string_list.contains("NotTata"));
68 ASSERT_TRUE(string_list.contains(str2));
69 ASSERT_FALSE(string_list.contains(str3));
70 ASSERT_TRUE(string_list.contains(str1));
71}
72
73void
74_checkSmallArrayValues(Span<const Int32> view)
75{
76 for( Int64 i=0, n=view.size(); i<n; ++i )
77 ASSERT_EQ(view[i],i+1);
78}
79
80void
81_checkSmallArrayValues(Span<const Int32> view1,Span<const Int32> view2)
82{
83 Int64 n1 = view1.size();
84 Int64 n2 = view2.size();
85 ASSERT_EQ(n1,n2);
86 for( Int64 i=0; i<n1; ++i )
87 ASSERT_EQ(view1[i],view2[i]);
88}
89
90TEST(Collections,SmallArray)
91{
92 {
93 constexpr int N = 934;
94 char buf[N];
95 impl::StackMemoryAllocator b(buf,N);
96 ASSERT_EQ(b.guarantedAlignment({}),0);
97 }
98 {
99 SmallArray<Int32,400> buf1;
100 for( Int32 i=0; i<200; ++i )
101 buf1.add(i+1);
102 ASSERT_EQ(buf1.size(),200);
103 _checkSmallArrayValues(buf1);
104
105 buf1.resize(50);
106 buf1.shrink();
107 ASSERT_EQ(buf1.size(),50);
108 _checkSmallArrayValues(buf1);
109
110 for( Int32 i=0; i<200; ++i )
111 buf1.add(50+i+1);
112 ASSERT_EQ(buf1.size(),250);
113 _checkSmallArrayValues(buf1);
114 }
115 for( int z=1; z<10; ++z ) {
116 UniqueArray<Int32> ref_buf(250*z);
117 for(Int32 i=0, n=ref_buf.size(); i<n; ++i )
118 ref_buf[i] = (i+1)*2;
119
120 UniqueArray<Int32> ref_buf2(100*z*z);
121 for(Int32 i=0, n=ref_buf2.size(); i<n; ++i )
122 ref_buf2[i] = (i+13)*3;
123
124 SmallArray<Int32,1024> buf2(ref_buf);
125 _checkSmallArrayValues(buf2,ref_buf);
126 SmallArray<Int32,1024> buf3(ref_buf.span());
127 _checkSmallArrayValues(buf3,ref_buf);
128 SmallArray<Int32,1024> buf4(ref_buf.constSpan());
129 _checkSmallArrayValues(buf4,ref_buf);
130 SmallArray<Int32,1024> buf5(ref_buf.view());
131 _checkSmallArrayValues(buf5,ref_buf);
132 SmallArray<Int32,1024> buf6(ref_buf.constView());
133 _checkSmallArrayValues(buf6,ref_buf);
134
135 buf2 = ref_buf2;
136 _checkSmallArrayValues(buf2,ref_buf2);
137 buf3 = ref_buf2.span();
138 _checkSmallArrayValues(buf3,ref_buf2);
139 buf4 = ref_buf2.constSpan();
140 _checkSmallArrayValues(buf4,ref_buf2);
141 buf5 = ref_buf2.view();
142 _checkSmallArrayValues(buf5,ref_buf2);
143 buf6 = ref_buf2.constView();
144 _checkSmallArrayValues(buf6,ref_buf2);
145 }
146 {
147 for( int z=1; z<10; ++z ) {
148 Int32 n = 5+(z*100);
149 SmallArray<Int32> buf3(n);
150 ASSERT_EQ(buf3.size(),n);
151 for(Int32 i=0; i<n; ++i )
152 buf3[i] = (i*22)+1;
153 for(Int32 i=0; i<n; ++i )
154 ASSERT_EQ(buf3[i],((i*22)+1));
155 }
156 }
157 {
158 std::cout << "Test initializer_list 1\n";
159 SmallArray<Int32,20> buf = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25,
160 27, 29, 31, 33, 35, 37, 39, 41 };
161 Int32 n = 21;
162 ASSERT_EQ(buf.size(),n);
163 for(Int32 i=0; i<n; ++i )
164 ASSERT_EQ(buf[i],((i*2)+1));
165 }
166 {
167 std::cout << "Test initializer_list 2\n";
168 SmallArray<Int32,100> buf = { 1, 3, 5, 7, 9, 11 };
169 Int32 n = 6;
170 ASSERT_EQ(buf.size(),n);
171 for(Int32 i=0; i<n; ++i )
172 ASSERT_EQ(buf[i],((i*2)+1));
173 }
174 {
175 size_t s1 = 513;
176 SmallArray<Int32> buf1(s1);
177 ASSERT_EQ(buf1.size(),s1);
178
179 Int64 s2 = 217;
180 SmallArray<Int32> buf2(s2);
181 ASSERT_EQ(buf2.size(),s2);
182 }
183}
184
185/*---------------------------------------------------------------------------*/
186/*---------------------------------------------------------------------------*/
187
188TEST(Collections, FixedArray)
189{
190#ifdef ARCANE_HAS_CXX20
191 static_assert(std::ranges::contiguous_range<FixedArray<Int32, 2>>);
192#endif
193
194 {
195 FixedArray<Int32, 0> empty_array;
196 ASSERT_EQ(empty_array.size(), 0);
197 ASSERT_EQ(empty_array.span().size(), 0);
198 }
199
200 {
201 static constexpr Int32 Size = 4;
202 FixedArray<Int32, Size> array1;
203 const FixedArray<Int32, Size>& const_array1(array1);
204 ASSERT_EQ(array1.size(), Size);
205 ASSERT_EQ(array1.span().size(), Size);
206 ASSERT_EQ(array1.view().size(), Size);
207 ASSERT_EQ(const_array1.span().size(), Size);
208 ASSERT_EQ(const_array1.view().size(), Size);
209 for (Int32 i = 0; i < Size; ++i) {
210 ASSERT_EQ(array1[i], 0);
211 ASSERT_EQ(array1.span()[i], 0);
212 ASSERT_EQ(array1.view()[i], 0);
213 ASSERT_EQ(const_array1.view()[i], 0);
214 }
215
216 array1[0] = 3;
217 array1[1] = 5;
218 array1[2] = -1;
219 array1[3] = 8;
220 ASSERT_EQ(array1[0], 3);
221 ASSERT_EQ(array1[1], 5);
222 ASSERT_EQ(const_array1[1], 5);
223 std::cout << "V[2]=" << array1[2] << "\n";
224 {
225 auto iter = array1.begin();
226 ASSERT_EQ(*iter, 3);
227 ASSERT_EQ(*iter, *const_array1.begin());
228 ++iter;
229 ASSERT_EQ(*iter, 5);
230 ++iter;
231 ASSERT_EQ(*iter, -1);
232 ++iter;
233 ASSERT_EQ(*iter, 8);
234 ++iter;
235 ASSERT_EQ(iter, array1.end());
236 ASSERT_EQ(iter, const_array1.end());
237 }
238 }
239 {
240 FixedArray<Int32, 2> v({ 1, 2 });
241 ASSERT_EQ(v[0], 1);
242 ASSERT_EQ(v[1], 2);
243 }
244 {
245 FixedArray<Int32, 2> v({ 3 });
246 ASSERT_EQ(v[0], 3);
247 ASSERT_EQ(v[1], 0);
248 }
249 {
250 UniqueArray<Int32> a1;
251 a1.add(3);
252 a1.add(5);
253 UniqueArray<Int32> a2;
254 a2.add(27);
255 a2.add(32);
256 a2.add(21);
257 FixedArray<UniqueArray<Int32>, 2> v({ a1, a2 });
258 ASSERT_EQ(v[0].size(), 2);
259 ASSERT_EQ(v[0][1], 5);
260 ASSERT_EQ(v[0][1], 5);
261 ASSERT_EQ(v[1].size(), 3);
262 ASSERT_EQ(v[1][0], 27);
263 ASSERT_EQ(v[1][1], 32);
264 ASSERT_EQ(v[1][2], 21);
265 FixedArray<UniqueArray<Int32>, 2> v2({ a1 });
266 v2 = { a2 };
267 ASSERT_EQ(v2[0].size(), 3);
268 ASSERT_EQ(v2[0][0], 27);
269 ASSERT_EQ(v2[0][1], 32);
270 ASSERT_EQ(v2[0][2], 21);
271 ASSERT_EQ(v2[1].size(), 0);
272 }
273}
274
275/*---------------------------------------------------------------------------*/
276/*---------------------------------------------------------------------------*/
277
278namespace Arcane
279{
280template class List<String>;
281template class ListImplBase<String>;
282template class ListImplT<String>;
283template class Collection<String>;
284template class CollectionImplT<String>;
285
286template class SmallArray<Int32>;
287template class FixedArray<Int32,3>;
288template class FixedArray<double, 21>;
289
290template class MultiArray2<Int32>;
291template class UniqueMultiArray2<Int32>;
292template class SharedMultiArray2<Int32>;
293}
294
295/*---------------------------------------------------------------------------*/
296/*---------------------------------------------------------------------------*/
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::AbstractArray::size
Integer size() const
Nombre d'éléments du vecteur.
Definition arccore/src/collections/arccore/collections/Array.h:423
Arcane::Array::shrink
void shrink()
Réalloue pour libérer la mémoire non utilisée.
Definition arccore/src/collections/arccore/collections/Array.h:1250
Arcane::Array::resize
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
Definition arccore/src/collections/arccore/collections/Array.h:1213
Arcane::Array::add
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
Definition arccore/src/collections/arccore/collections/Array.h:1170
Arcane::CollectionImplT
classe de base d'implémentation d'une collection typée.
Definition CollectionImpl.h:217
Arcane::Collection
Classe de base d'une collection fortement typée.
Definition Collection.h:115
Arcane::FixedArray
Tableau 1D de taille fixe.
Definition FixedArray.h:45
Arcane::FixedArray::view
constexpr __host__ __device__ ArrayView< T > view()
Vue modifiable sur le tableau.
Definition FixedArray.h:97
Arcane::FixedArray::span
constexpr __host__ __device__ SmallSpan< T, NbElement > span()
Vue modifiable sur le tableau.
Definition FixedArray.h:93
Arcane::FixedArray::size
static constexpr Int32 size()
Nombre d'éléments tu tableau.
Definition FixedArray.h:104
Arcane::ListImplBase
Tableau avec allocateur virtuel.
Definition ListImpl.h:45
Arcane::List
Implémentation d'une collection d'éléments sous forme de vecteur.
Definition List.h:222
Arcane::MultiArray2
Classe de base des tableau 2D à taille multiple.
Definition MultiArray2.h:61
Arcane::SharedMultiArray2
Tableau 2D à taille multiple avec sémantique par référence.
Definition MultiArray2.h:320
Arcane::SmallArray
Tableau 1D de données avec buffer pré-alloué sur la pile.
Definition SmallArray.h:89
Arcane::SpanImpl::size
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
Definition Span.h:212
Arcane::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/collections/arccore/collections/Array.h:1844
Arcane::UniqueMultiArray2
Tableau 2D à taille multiple avec sémantique par valeur.
Definition MultiArray2.h:375
Arcane::impl::StackMemoryAllocator
Allocateur avec buffer pré-alloué.
Definition SmallArray.h:40
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::StringList
List< String > StringList
Tableau de chaînes de caractères unicode.
Definition UtilsTypes.h:596