Line data Source code
1 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3 : !!!! !!!!
4 : !!!! ParaMonte: Parallel Monte Carlo and Machine Learning Library. !!!!
5 : !!!! !!!!
6 : !!!! Copyright (C) 2012-present, The Computational Data Science Lab !!!!
7 : !!!! !!!!
8 : !!!! This file is part of the ParaMonte library. !!!!
9 : !!!! !!!!
10 : !!!! LICENSE !!!!
11 : !!!! !!!!
12 : !!!! https://github.com/cdslaborg/paramonte/blob/main/LICENSE.md !!!!
13 : !!!! !!!!
14 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
15 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
16 :
17 : !> \brief
18 : !> This module contains implementations of the tests of the procedures under the generic interfaces of [pm_arraySplit](@ref pm_arraySplit).
19 : !>
20 : !> \fintest
21 : !>
22 : !> \author
23 : !> \AmirShahmoradi, September 1, 2017, 11:35 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
24 :
25 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
26 :
27 : #if LK_ENABLED && D1_D1_ENABLED
28 : #define IS_EQUAL .eqv.
29 : #else
30 : #define IS_EQUAL ==
31 : #endif
32 :
33 : #if SK_ENABLED && D0_D0_ENABLED
34 : #define GET_SIZE(array) len(array, kind = IK)
35 : #define ALL
36 : #else
37 : #define GET_SIZE(array) size(array, kind = IK)
38 : #endif
39 : character(*, SK), parameter :: PROCEDURE_NAME = "@split()"
40 : #if SK_ENABLED && D0_D0_ENABLED
41 : #if CVXK_ENABLED
42 1 : type(css_type), allocatable :: field(:), field_ref(:)
43 : #elif PVXK_ENABLED
44 : type(css_pdt(SKC)), allocatable :: field(:), field_ref(:)
45 : #endif
46 2 : character(:,SKC), allocatable :: array, sep
47 : #elif SK_ENABLED && D1_D1_ENABLED
48 : #if CVXK_ENABLED
49 1 : type(cvs_type), allocatable :: field(:), field_ref(:)
50 : #elif PVXK_ENABLED
51 : type(cvs_pdt(SKC)), allocatable :: field(:), field_ref(:)
52 : #endif
53 : character(2,SKC), allocatable :: array(:), sep(:)
54 : #elif IK_ENABLED && D1_D1_ENABLED
55 : #if CVXK_ENABLED
56 1 : type(cvi_type), allocatable :: field(:), field_ref(:)
57 : #elif PVXK_ENABLED
58 : type(cvi_pdt(IKC)), allocatable :: field(:), field_ref(:)
59 : #endif
60 : integer(IKC), allocatable :: array(:), sep(:)
61 : #elif LK_ENABLED && D1_D1_ENABLED
62 : #if CVXK_ENABLED
63 1 : type(cvl_type), allocatable :: field(:), field_ref(:)
64 : #elif PVXK_ENABLED
65 : type(cvl_pdt(LKC)), allocatable :: field(:), field_ref(:)
66 : #endif
67 : logical(LKC), allocatable :: array(:), sep(:)
68 : #elif CK_ENABLED && D1_D1_ENABLED
69 : #if CVXK_ENABLED
70 1 : type(cvc_type), allocatable :: field(:), field_ref(:)
71 : #elif PVXK_ENABLED
72 : type(cvc_pdt(CKC)), allocatable :: field(:), field_ref(:)
73 : #endif
74 : complex(CKC), allocatable :: array(:), sep(:)
75 : #elif RK_ENABLED && D1_D1_ENABLED
76 : #if CVXK_ENABLED
77 1 : type(cvr_type), allocatable :: field(:), field_ref(:)
78 : #elif PVXK_ENABLED
79 : type(cvr_pdt(RKC)), allocatable :: field(:), field_ref(:)
80 : #endif
81 : real(RKC), allocatable :: array(:), sep(:)
82 : #else
83 : #error "Unrecognized interface."
84 : #endif
85 : integer(IK), allocatable :: sindex(:,:), sindex_ref(:,:)
86 : integer(IK), allocatable :: instance(:)
87 : integer(IK) :: i
88 :
89 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
90 :
91 26 : assertion = .true._LK
92 97 : do i = 1, 2 ! repeat for index splitting.
93 52 : call runTestsWith()
94 52 : call runTestsWith(iseq = iseq)
95 52 : call runTestsWith(keep = .true._LK)
96 52 : call runTestsWith(keep = .false._LK)
97 52 : call runTestsWith(iseq = iseq, keep = .true._LK)
98 78 : call runTestsWith(iseq = iseq, keep = .false._LK)
99 : end do
100 :
101 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
102 :
103 : contains
104 :
105 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
106 :
107 : function iseq(Segment, sep & !LCOV_EXCL_LINE
108 : #if !(SK_ENABLED && D0_D0_ENABLED)
109 : , lenDelim & !LCOV_EXCL_LINE
110 : #endif
111 : ) result(equivalent)
112 : logical(LK) :: equivalent
113 : #if !(SK_ENABLED && D0_D0_ENABLED)
114 : integer(IK), intent(in) :: lenDelim
115 : #endif
116 : #if SK_ENABLED && D0_D0_ENABLED
117 : character(*,SKC), intent(in) :: sep, Segment
118 : #elif SK_ENABLED && D1_D1_ENABLED
119 : character(*,SKC), intent(in) :: Segment(lenDelim), sep(lenDelim)
120 : #elif IK_ENABLED && D1_D1_ENABLED
121 : integer(IKC) , intent(in) :: Segment(lenDelim), sep(lenDelim)
122 : #elif LK_ENABLED && D1_D1_ENABLED
123 : logical(LKC) , intent(in) :: Segment(lenDelim), sep(lenDelim)
124 : #elif CK_ENABLED && D1_D1_ENABLED
125 : complex(CKC) , intent(in) :: Segment(lenDelim), sep(lenDelim)
126 : #elif RK_ENABLED && D1_D1_ENABLED
127 : real(RKC) , intent(in) :: Segment(lenDelim), sep(lenDelim)
128 : #endif
129 82980 : equivalent = ALL(sep IS_EQUAL Segment)
130 49920 : end function
131 :
132 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
133 :
134 5616 : subroutine reset()
135 5616 : if (allocated(array)) deallocate(array)
136 5616 : if (allocated(instance)) deallocate(instance)
137 5616 : if (allocated(sep)) deallocate(sep)
138 5616 : if (allocated(sindex)) deallocate(sindex)
139 5616 : if (allocated(sindex_ref)) deallocate(sindex_ref)
140 : #if CVXK_ENABLED || PVXK_ENABLED
141 4314 : if (allocated(field_ref)) deallocate(field_ref) ! \bug gfortran 11 will not even compile this line.
142 4314 : if (allocated(field)) deallocate(field) ! \bug gfortran 11 will not even compile this line.
143 : #endif
144 5616 : end subroutine
145 :
146 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
147 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
148 :
149 312 : subroutine runTestsWith(iseq, keep)
150 : logical(LK) , intent(in), optional :: keep
151 : logical(LK) , external , optional :: iseq
152 :
153 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
154 :
155 312 : call reset()
156 :
157 : #if SK_ENABLED && D0_D0_ENABLED
158 24 : array = ""
159 24 : sep = " "
160 : #elif SK_ENABLED && D1_D1_ENABLED
161 72 : sep = [" "]
162 24 : allocate(array(0))
163 : #elif IK_ENABLED && D1_D1_ENABLED
164 216 : sep = [1_IKC]
165 72 : allocate(array(0))
166 : #elif LK_ENABLED && D1_D1_ENABLED
167 216 : sep = [.false._LK]
168 72 : allocate(array(0))
169 : #elif CK_ENABLED && D1_D1_ENABLED
170 180 : sep = [1._CKC]
171 60 : allocate(array(0))
172 : #elif RK_ENABLED && D1_D1_ENABLED
173 180 : sep = [1._RKC]
174 60 : allocate(array(0))
175 : #endif
176 : #if CVXK_ENABLED || PVXK_ENABLED
177 168 : allocate(field_ref(1))
178 132 : field_ref(1)%val = array
179 : #endif
180 :
181 312 : allocate(sindex_ref(2,1))
182 312 : sindex_ref(1,1) = 1
183 312 : sindex_ref(2,1) = 0
184 :
185 312 : allocate(instance(0))
186 :
187 312 : call reportDelim(iseq, keep)
188 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting array.", int(__LINE__, IK))
189 :
190 312 : call reportDelim(iseq, keep, instance = instance)
191 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting array with `instance`.", int(__LINE__, IK))
192 :
193 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
194 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting array with `instance` with `sorted = .true.`.", int(__LINE__, IK))
195 :
196 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
197 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting array with `instance` with `sorted = .false.`.", int(__LINE__, IK))
198 :
199 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
200 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting array with `instance` with `unique = .true.`.", int(__LINE__, IK))
201 :
202 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
203 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting array with `instance` with `unique = .false.`.", int(__LINE__, IK))
204 :
205 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
206 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting array with `instance` with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
207 :
208 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .true._LK)
209 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting array with `instance` with `sorted = .false._LK, unique = .true.`.", int(__LINE__, IK))
210 :
211 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
212 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting array with `instance` with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
213 :
214 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
215 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting array with `instance` with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
216 :
217 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
218 :
219 312 : call reset()
220 :
221 : #if SK_ENABLED && D0_D0_ENABLED
222 24 : array = "AA"
223 24 : sep = ""
224 : #elif SK_ENABLED && D1_D1_ENABLED
225 96 : array = ["AA", "AA"]
226 24 : allocate(character(2) :: sep(0))
227 : #elif IK_ENABLED && D1_D1_ENABLED
228 288 : array = [1_IKC, 1_IKC]
229 72 : allocate(sep(0))
230 : #elif LK_ENABLED && D1_D1_ENABLED
231 288 : array = [.false._LK, .false._LK]
232 72 : allocate(sep(0))
233 : #elif CK_ENABLED && D1_D1_ENABLED
234 240 : array = [1._CKC, 1._CKC]
235 60 : allocate(sep(0))
236 : #elif RK_ENABLED && D1_D1_ENABLED
237 240 : array = [1._RKC, 1._RKC]
238 60 : allocate(sep(0))
239 : #endif
240 : #if CVXK_ENABLED || PVXK_ENABLED
241 168 : allocate(field_ref(1))
242 312 : field_ref(1)%val = array
243 : #endif
244 312 : allocate(sindex_ref(2,1))
245 312 : sindex_ref(1,1) = 1
246 312 : sindex_ref(2,1) = 2
247 :
248 312 : allocate(instance(0))
249 :
250 312 : call reportDelim(iseq, keep)
251 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued.", int(__LINE__, IK))
252 :
253 312 : call reportDelim(iseq, keep, instance = instance)
254 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is empty.", int(__LINE__, IK))
255 :
256 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
257 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is empty with `sorted = .true.`.", int(__LINE__, IK))
258 :
259 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
260 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is empty with `sorted = .false.`.", int(__LINE__, IK))
261 :
262 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
263 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is empty with `unique = .true.`.", int(__LINE__, IK))
264 :
265 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
266 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is empty with `unique = .false.`.", int(__LINE__, IK))
267 :
268 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
269 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is empty with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
270 :
271 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .true._LK)
272 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is empty with `sorted = .false._LK, unique = .true.`.", int(__LINE__, IK))
273 :
274 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
275 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is empty with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
276 :
277 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
278 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is empty with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
279 :
280 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
281 :
282 312 : call reset()
283 :
284 : #if SK_ENABLED && D0_D0_ENABLED
285 24 : array = "AA"
286 24 : sep = ""
287 : #elif SK_ENABLED && D1_D1_ENABLED
288 96 : array = ["AA", "AA"]
289 24 : allocate(character(2) :: sep(0))
290 : #elif IK_ENABLED && D1_D1_ENABLED
291 288 : array = [1_IKC, 1_IKC]
292 72 : allocate(sep(0))
293 : #elif LK_ENABLED && D1_D1_ENABLED
294 288 : array = [.false._LK, .false._LK]
295 72 : allocate(sep(0))
296 : #elif CK_ENABLED && D1_D1_ENABLED
297 240 : array = [1._CKC, 1._CKC]
298 60 : allocate(sep(0))
299 : #elif RK_ENABLED && D1_D1_ENABLED
300 240 : array = [1._RKC, 1._RKC]
301 60 : allocate(sep(0))
302 : #endif
303 : #if CVXK_ENABLED || PVXK_ENABLED
304 168 : allocate(field_ref(1))
305 312 : field_ref(1)%val = array
306 : #endif
307 312 : allocate(sindex_ref(2,1))
308 312 : sindex_ref(1,1) = 1
309 312 : sindex_ref(2,1) = 2
310 :
311 936 : instance = [1_IK]
312 :
313 312 : call reportDelim(iseq, keep)
314 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued.", int(__LINE__, IK))
315 :
316 312 : call reportDelim(iseq, keep, instance = instance)
317 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is non-empty.", int(__LINE__, IK))
318 :
319 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
320 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is non-empty with `sorted = .true.`.", int(__LINE__, IK))
321 :
322 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
323 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is non-empty with `sorted = .false.`.", int(__LINE__, IK))
324 :
325 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
326 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is non-empty with `unique = .true.`.", int(__LINE__, IK))
327 :
328 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
329 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is non-empty with `unique = .false.`.", int(__LINE__, IK))
330 :
331 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
332 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is non-empty with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
333 :
334 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .true._LK)
335 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is non-empty with `sorted = .false._LK, unique = .true.`.", int(__LINE__, IK))
336 :
337 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
338 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is non-empty with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
339 :
340 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
341 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `sep` must yield an `field` of size 1 whose sole component is `array`-valued when `instance` is non-empty with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
342 :
343 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
344 :
345 312 : call reset()
346 :
347 : #if CVXK_ENABLED || PVXK_ENABLED
348 72 : if (getOption(.false._LK, keep)) then
349 144 : allocate(field_ref(5))
350 : else
351 192 : allocate(field_ref(3))
352 : endif
353 : #endif
354 : #if SK_ENABLED && D0_D0_ENABLED
355 24 : array = "AA"
356 24 : sep = "A"
357 : #if CVXK_ENABLED || PVXK_ENABLED
358 12 : if (getOption(.false._LK, keep)) then
359 4 : field_ref(1)%val = ""
360 4 : field_ref(2)%val = sep
361 4 : field_ref(3)%val = ""
362 4 : field_ref(4)%val = sep
363 4 : field_ref(5)%val = ""
364 : else
365 8 : field_ref(1)%val = ""
366 8 : field_ref(2)%val = ""
367 8 : field_ref(3)%val = ""
368 : endif
369 : #endif
370 : #elif SK_ENABLED && D1_D1_ENABLED
371 96 : array = ["AA", "AA"]
372 72 : sep = ["AA"]
373 : #if CVXK_ENABLED || PVXK_ENABLED
374 12 : if (getOption(.false._LK, keep)) then
375 4 : allocate(character(2,SKC) :: field_ref(1)%val(0))
376 16 : field_ref(2)%val = sep
377 4 : allocate(character(2,SKC) :: field_ref(3)%val(0))
378 16 : field_ref(4)%val = sep
379 4 : allocate(character(2,SKC) :: field_ref(5)%val(0))
380 : else
381 8 : allocate(character(2,SKC) :: field_ref(1)%val(0))
382 8 : allocate(character(2,SKC) :: field_ref(2)%val(0))
383 8 : allocate(character(2,SKC) :: field_ref(3)%val(0))
384 : endif
385 : #endif
386 : #elif IK_ENABLED && D1_D1_ENABLED
387 288 : array = [1_IKC, 1_IKC]
388 216 : sep = [1_IKC]
389 : #if CVXK_ENABLED || PVXK_ENABLED
390 12 : if (getOption(.false._LK, keep)) then
391 4 : allocate(field_ref(1)%val(0))
392 16 : field_ref(2)%val = sep
393 4 : allocate(field_ref(3)%val(0))
394 16 : field_ref(4)%val = sep
395 4 : allocate(field_ref(5)%val(0))
396 : else
397 8 : allocate(field_ref(1)%val(0))
398 8 : allocate(field_ref(2)%val(0))
399 8 : allocate(field_ref(3)%val(0))
400 : endif
401 : #endif
402 : #elif LK_ENABLED && D1_D1_ENABLED
403 288 : array = [.false._LK, .false._LK]
404 216 : sep = [.false._LK]
405 : #if CVXK_ENABLED || PVXK_ENABLED
406 12 : if (getOption(.false._LK, keep)) then
407 4 : allocate(field_ref(1)%val(0))
408 16 : field_ref(2)%val = sep
409 4 : allocate(field_ref(3)%val(0))
410 16 : field_ref(4)%val = sep
411 4 : allocate(field_ref(5)%val(0))
412 : else
413 8 : allocate(field_ref(1)%val(0))
414 8 : allocate(field_ref(2)%val(0))
415 8 : allocate(field_ref(3)%val(0))
416 : endif
417 : #endif
418 : #elif CK_ENABLED && D1_D1_ENABLED
419 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
420 180 : sep = [(1._CKC,-1._CKC)]
421 : #if CVXK_ENABLED || PVXK_ENABLED
422 12 : if (getOption(.false._LK, keep)) then
423 4 : allocate(field_ref(1)%val(0))
424 16 : field_ref(2)%val = sep
425 4 : allocate(field_ref(3)%val(0))
426 16 : field_ref(4)%val = sep
427 4 : allocate(field_ref(5)%val(0))
428 : else
429 8 : allocate(field_ref(1)%val(0))
430 8 : allocate(field_ref(2)%val(0))
431 8 : allocate(field_ref(3)%val(0))
432 : endif
433 : #endif
434 : #elif RK_ENABLED && D1_D1_ENABLED
435 240 : array = [1._RKC, 1._RKC]
436 180 : sep = [1._RKC]
437 : #if CVXK_ENABLED || PVXK_ENABLED
438 12 : if (getOption(.false._LK, keep)) then
439 4 : allocate(field_ref(1)%val(0))
440 16 : field_ref(2)%val = sep
441 4 : allocate(field_ref(3)%val(0))
442 16 : field_ref(4)%val = sep
443 4 : allocate(field_ref(5)%val(0))
444 : else
445 8 : allocate(field_ref(1)%val(0))
446 8 : allocate(field_ref(2)%val(0))
447 8 : allocate(field_ref(3)%val(0))
448 : endif
449 : #endif
450 : #endif
451 312 : if (getOption(.false._LK, keep)) then
452 104 : allocate(sindex_ref(2,5))
453 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
454 104 : sindex_ref(1,2) = 1; sindex_ref(2,2) = 1
455 104 : sindex_ref(1,3) = 2; sindex_ref(2,3) = 1
456 104 : sindex_ref(1,4) = 2; sindex_ref(2,4) = 2
457 104 : sindex_ref(1,5) = 3; sindex_ref(2,5) = 2
458 : else
459 208 : allocate(sindex_ref(2,3))
460 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
461 208 : sindex_ref(1,2) = 2; sindex_ref(2,2) = 1
462 208 : sindex_ref(1,3) = 3; sindex_ref(2,3) = 2
463 : end if
464 :
465 1248 : instance = [1_IK, 2_IK]
466 :
467 312 : call reportDelim(iseq, keep)
468 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty.", int(__LINE__, IK))
469 :
470 312 : call reportDelim(iseq, keep, instance = instance)
471 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty.", int(__LINE__, IK))
472 :
473 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
474 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty with `sorted = .true.`.", int(__LINE__, IK))
475 :
476 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
477 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty with `sorted = .false.`.", int(__LINE__, IK))
478 :
479 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
480 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty with `unique = .true.`.", int(__LINE__, IK))
481 :
482 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
483 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty with `unique = .false.`.", int(__LINE__, IK))
484 :
485 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
486 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
487 :
488 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .true._LK)
489 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty with `sorted = .false._LK, unique = .true.`.", int(__LINE__, IK))
490 :
491 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
492 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
493 :
494 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
495 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
496 :
497 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
498 :
499 312 : call reset()
500 :
501 : #if CVXK_ENABLED || PVXK_ENABLED
502 72 : if (getOption(.false._LK, keep)) then
503 144 : allocate(field_ref(5))
504 : else
505 192 : allocate(field_ref(3))
506 : endif
507 : #endif
508 : #if SK_ENABLED && D0_D0_ENABLED
509 24 : array = "AA"
510 24 : sep = "A"
511 : #if CVXK_ENABLED || PVXK_ENABLED
512 12 : if (getOption(.false._LK, keep)) then
513 4 : field_ref(1)%val = ""
514 4 : field_ref(2)%val = sep
515 4 : field_ref(3)%val = ""
516 4 : field_ref(4)%val = sep
517 4 : field_ref(5)%val = ""
518 : else
519 8 : field_ref(1)%val = ""
520 8 : field_ref(2)%val = ""
521 8 : field_ref(3)%val = ""
522 : endif
523 : #endif
524 : #elif SK_ENABLED && D1_D1_ENABLED
525 96 : array = ["AA", "AA"]
526 72 : sep = ["AA"]
527 : #if CVXK_ENABLED || PVXK_ENABLED
528 12 : if (getOption(.false._LK, keep)) then
529 4 : allocate(character(2,SKC) :: field_ref(1)%val(0))
530 16 : field_ref(2)%val = sep
531 4 : allocate(character(2,SKC) :: field_ref(3)%val(0))
532 16 : field_ref(4)%val = sep
533 4 : allocate(character(2,SKC) :: field_ref(5)%val(0))
534 : else
535 8 : allocate(character(2,SKC) :: field_ref(1)%val(0))
536 8 : allocate(character(2,SKC) :: field_ref(2)%val(0))
537 8 : allocate(character(2,SKC) :: field_ref(3)%val(0))
538 : endif
539 : #endif
540 : #elif IK_ENABLED && D1_D1_ENABLED
541 288 : array = [1_IKC, 1_IKC]
542 216 : sep = [1_IKC]
543 : #if CVXK_ENABLED || PVXK_ENABLED
544 12 : if (getOption(.false._LK, keep)) then
545 4 : allocate(field_ref(1)%val(0))
546 16 : field_ref(2)%val = sep
547 4 : allocate(field_ref(3)%val(0))
548 16 : field_ref(4)%val = sep
549 4 : allocate(field_ref(5)%val(0))
550 : else
551 8 : allocate(field_ref(1)%val(0))
552 8 : allocate(field_ref(2)%val(0))
553 8 : allocate(field_ref(3)%val(0))
554 : endif
555 : #endif
556 : #elif LK_ENABLED && D1_D1_ENABLED
557 288 : array = [.false._LK, .false._LK]
558 216 : sep = [.false._LK]
559 : #if CVXK_ENABLED || PVXK_ENABLED
560 12 : if (getOption(.false._LK, keep)) then
561 4 : allocate(field_ref(1)%val(0))
562 16 : field_ref(2)%val = sep
563 4 : allocate(field_ref(3)%val(0))
564 16 : field_ref(4)%val = sep
565 4 : allocate(field_ref(5)%val(0))
566 : else
567 8 : allocate(field_ref(1)%val(0))
568 8 : allocate(field_ref(2)%val(0))
569 8 : allocate(field_ref(3)%val(0))
570 : endif
571 : #endif
572 : #elif CK_ENABLED && D1_D1_ENABLED
573 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
574 180 : sep = [(1._CKC,-1._CKC)]
575 : #if CVXK_ENABLED || PVXK_ENABLED
576 12 : if (getOption(.false._LK, keep)) then
577 4 : allocate(field_ref(1)%val(0))
578 16 : field_ref(2)%val = sep
579 4 : allocate(field_ref(3)%val(0))
580 16 : field_ref(4)%val = sep
581 4 : allocate(field_ref(5)%val(0))
582 : else
583 8 : allocate(field_ref(1)%val(0))
584 8 : allocate(field_ref(2)%val(0))
585 8 : allocate(field_ref(3)%val(0))
586 : endif
587 : #endif
588 : #elif RK_ENABLED && D1_D1_ENABLED
589 240 : array = [1._RKC, 1._RKC]
590 180 : sep = [1._RKC]
591 : #if CVXK_ENABLED || PVXK_ENABLED
592 12 : if (getOption(.false._LK, keep)) then
593 4 : allocate(field_ref(1)%val(0))
594 16 : field_ref(2)%val = sep
595 4 : allocate(field_ref(3)%val(0))
596 16 : field_ref(4)%val = sep
597 4 : allocate(field_ref(5)%val(0))
598 : else
599 8 : allocate(field_ref(1)%val(0))
600 8 : allocate(field_ref(2)%val(0))
601 8 : allocate(field_ref(3)%val(0))
602 : endif
603 : #endif
604 : #endif
605 312 : if (getOption(.false._LK, keep)) then
606 104 : allocate(sindex_ref(2,5))
607 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
608 104 : sindex_ref(1,2) = 1; sindex_ref(2,2) = 1
609 104 : sindex_ref(1,3) = 2; sindex_ref(2,3) = 1
610 104 : sindex_ref(1,4) = 2; sindex_ref(2,4) = 2
611 104 : sindex_ref(1,5) = 3; sindex_ref(2,5) = 2
612 : else
613 208 : allocate(sindex_ref(2,3))
614 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
615 208 : sindex_ref(1,2) = 2; sindex_ref(2,2) = 1
616 208 : sindex_ref(1,3) = 3; sindex_ref(2,3) = 2
617 : end if
618 :
619 1872 : instance = [0_IK, 1_IK, 2_IK, 3_IK]
620 :
621 312 : call reportDelim(iseq, keep)
622 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty.", int(__LINE__, IK))
623 :
624 312 : call reportDelim(iseq, keep, instance = instance)
625 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and redundant.", int(__LINE__, IK))
626 :
627 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
628 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and redundant with `sorted = .true.`.", int(__LINE__, IK))
629 :
630 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
631 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and redundant with `sorted = .false.`.", int(__LINE__, IK))
632 :
633 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
634 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and redundant with `unique = .true.`.", int(__LINE__, IK))
635 :
636 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
637 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and redundant with `unique = .false.`.", int(__LINE__, IK))
638 :
639 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
640 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and redundant with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
641 :
642 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .true._LK)
643 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and redundant with `sorted = .false._LK, unique = .true.`.", int(__LINE__, IK))
644 :
645 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
646 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and redundant with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
647 :
648 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
649 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and redundant with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
650 :
651 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
652 :
653 312 : call reset()
654 :
655 : #if CVXK_ENABLED || PVXK_ENABLED
656 72 : if (getOption(.false._LK, keep)) then
657 144 : allocate(field_ref(5))
658 : else
659 192 : allocate(field_ref(3))
660 : endif
661 : #endif
662 : #if SK_ENABLED && D0_D0_ENABLED
663 24 : array = "AA"
664 24 : sep = "A"
665 : #if CVXK_ENABLED || PVXK_ENABLED
666 12 : if (getOption(.false._LK, keep)) then
667 4 : field_ref(1)%val = ""
668 4 : field_ref(2)%val = sep
669 4 : field_ref(3)%val = ""
670 4 : field_ref(4)%val = sep
671 4 : field_ref(5)%val = ""
672 : else
673 8 : field_ref(1)%val = ""
674 8 : field_ref(2)%val = ""
675 8 : field_ref(3)%val = ""
676 : endif
677 : #endif
678 : #elif SK_ENABLED && D1_D1_ENABLED
679 96 : array = ["AA", "AA"]
680 72 : sep = ["AA"]
681 : #if CVXK_ENABLED || PVXK_ENABLED
682 12 : if (getOption(.false._LK, keep)) then
683 4 : allocate(character(2,SKC) :: field_ref(1)%val(0))
684 16 : field_ref(2)%val = sep
685 4 : allocate(character(2,SKC) :: field_ref(3)%val(0))
686 16 : field_ref(4)%val = sep
687 4 : allocate(character(2,SKC) :: field_ref(5)%val(0))
688 : else
689 8 : allocate(character(2,SKC) :: field_ref(1)%val(0))
690 8 : allocate(character(2,SKC) :: field_ref(2)%val(0))
691 8 : allocate(character(2,SKC) :: field_ref(3)%val(0))
692 : endif
693 : #endif
694 : #elif IK_ENABLED && D1_D1_ENABLED
695 288 : array = [1_IKC, 1_IKC]
696 216 : sep = [1_IKC]
697 : #if CVXK_ENABLED || PVXK_ENABLED
698 12 : if (getOption(.false._LK, keep)) then
699 4 : allocate(field_ref(1)%val(0))
700 16 : field_ref(2)%val = sep
701 4 : allocate(field_ref(3)%val(0))
702 16 : field_ref(4)%val = sep
703 4 : allocate(field_ref(5)%val(0))
704 : else
705 8 : allocate(field_ref(1)%val(0))
706 8 : allocate(field_ref(2)%val(0))
707 8 : allocate(field_ref(3)%val(0))
708 : endif
709 : #endif
710 : #elif LK_ENABLED && D1_D1_ENABLED
711 288 : array = [.false._LK, .false._LK]
712 216 : sep = [.false._LK]
713 : #if CVXK_ENABLED || PVXK_ENABLED
714 12 : if (getOption(.false._LK, keep)) then
715 4 : allocate(field_ref(1)%val(0))
716 16 : field_ref(2)%val = sep
717 4 : allocate(field_ref(3)%val(0))
718 16 : field_ref(4)%val = sep
719 4 : allocate(field_ref(5)%val(0))
720 : else
721 8 : allocate(field_ref(1)%val(0))
722 8 : allocate(field_ref(2)%val(0))
723 8 : allocate(field_ref(3)%val(0))
724 : endif
725 : #endif
726 : #elif CK_ENABLED && D1_D1_ENABLED
727 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
728 180 : sep = [(1._CKC,-1._CKC)]
729 : #if CVXK_ENABLED || PVXK_ENABLED
730 12 : if (getOption(.false._LK, keep)) then
731 4 : allocate(field_ref(1)%val(0))
732 16 : field_ref(2)%val = sep
733 4 : allocate(field_ref(3)%val(0))
734 16 : field_ref(4)%val = sep
735 4 : allocate(field_ref(5)%val(0))
736 : else
737 8 : allocate(field_ref(1)%val(0))
738 8 : allocate(field_ref(2)%val(0))
739 8 : allocate(field_ref(3)%val(0))
740 : endif
741 : #endif
742 : #elif RK_ENABLED && D1_D1_ENABLED
743 240 : array = [1._RKC, 1._RKC]
744 180 : sep = [1._RKC]
745 : #if CVXK_ENABLED || PVXK_ENABLED
746 12 : if (getOption(.false._LK, keep)) then
747 4 : allocate(field_ref(1)%val(0))
748 16 : field_ref(2)%val = sep
749 4 : allocate(field_ref(3)%val(0))
750 16 : field_ref(4)%val = sep
751 4 : allocate(field_ref(5)%val(0))
752 : else
753 8 : allocate(field_ref(1)%val(0))
754 8 : allocate(field_ref(2)%val(0))
755 8 : allocate(field_ref(3)%val(0))
756 : endif
757 : #endif
758 : #endif
759 312 : if (getOption(.false._LK, keep)) then
760 104 : allocate(sindex_ref(2,5))
761 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
762 104 : sindex_ref(1,2) = 1; sindex_ref(2,2) = 1
763 104 : sindex_ref(1,3) = 2; sindex_ref(2,3) = 1
764 104 : sindex_ref(1,4) = 2; sindex_ref(2,4) = 2
765 104 : sindex_ref(1,5) = 3; sindex_ref(2,5) = 2
766 : else
767 208 : allocate(sindex_ref(2,3))
768 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
769 208 : sindex_ref(1,2) = 2; sindex_ref(2,2) = 1
770 208 : sindex_ref(1,3) = 3; sindex_ref(2,3) = 2
771 : end if
772 :
773 1248 : instance = [1_IK, -1_IK]
774 :
775 312 : call reportDelim(iseq, keep)
776 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty.", int(__LINE__, IK))
777 :
778 312 : call reportDelim(iseq, keep, instance = instance)
779 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and mixed.", int(__LINE__, IK))
780 :
781 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
782 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and mixed with `sorted = .true.`.", int(__LINE__, IK))
783 :
784 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
785 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and mixed with `sorted = .false.`.", int(__LINE__, IK))
786 :
787 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
788 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and mixed with `unique = .true.`.", int(__LINE__, IK))
789 :
790 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
791 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and mixed with `unique = .false.`.", int(__LINE__, IK))
792 :
793 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
794 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and mixed with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
795 :
796 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .true._LK)
797 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and mixed with `sorted = .false._LK, unique = .true.`.", int(__LINE__, IK))
798 :
799 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
800 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and mixed with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
801 :
802 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
803 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty and mixed with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
804 :
805 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
806 :
807 312 : call reset()
808 :
809 : #if CVXK_ENABLED || PVXK_ENABLED
810 72 : if (getOption(.false._LK, keep)) then
811 144 : allocate(field_ref(5))
812 : else
813 192 : allocate(field_ref(3))
814 : endif
815 : #endif
816 : #if SK_ENABLED && D0_D0_ENABLED
817 24 : array = "AA"
818 24 : sep = "A"
819 : #if CVXK_ENABLED || PVXK_ENABLED
820 12 : if (getOption(.false._LK, keep)) then
821 4 : field_ref(1)%val = ""
822 4 : field_ref(2)%val = sep
823 4 : field_ref(3)%val = ""
824 4 : field_ref(4)%val = sep
825 4 : field_ref(5)%val = ""
826 : else
827 8 : field_ref(1)%val = ""
828 8 : field_ref(2)%val = ""
829 8 : field_ref(3)%val = ""
830 : endif
831 : #endif
832 : #elif SK_ENABLED && D1_D1_ENABLED
833 96 : array = ["AA", "AA"]
834 72 : sep = ["AA"]
835 : #if CVXK_ENABLED || PVXK_ENABLED
836 12 : if (getOption(.false._LK, keep)) then
837 4 : allocate(character(2,SKC) :: field_ref(1)%val(0))
838 16 : field_ref(2)%val = sep
839 4 : allocate(character(2,SKC) :: field_ref(3)%val(0))
840 16 : field_ref(4)%val = sep
841 4 : allocate(character(2,SKC) :: field_ref(5)%val(0))
842 : else
843 8 : allocate(character(2,SKC) :: field_ref(1)%val(0))
844 8 : allocate(character(2,SKC) :: field_ref(2)%val(0))
845 8 : allocate(character(2,SKC) :: field_ref(3)%val(0))
846 : endif
847 : #endif
848 : #elif IK_ENABLED && D1_D1_ENABLED
849 288 : array = [1_IKC, 1_IKC]
850 216 : sep = [1_IKC]
851 : #if CVXK_ENABLED || PVXK_ENABLED
852 12 : if (getOption(.false._LK, keep)) then
853 4 : allocate(field_ref(1)%val(0))
854 16 : field_ref(2)%val = sep
855 4 : allocate(field_ref(3)%val(0))
856 16 : field_ref(4)%val = sep
857 4 : allocate(field_ref(5)%val(0))
858 : else
859 8 : allocate(field_ref(1)%val(0))
860 8 : allocate(field_ref(2)%val(0))
861 8 : allocate(field_ref(3)%val(0))
862 : endif
863 : #endif
864 : #elif LK_ENABLED && D1_D1_ENABLED
865 288 : array = [.false._LK, .false._LK]
866 216 : sep = [.false._LK]
867 : #if CVXK_ENABLED || PVXK_ENABLED
868 12 : if (getOption(.false._LK, keep)) then
869 4 : allocate(field_ref(1)%val(0))
870 16 : field_ref(2)%val = sep
871 4 : allocate(field_ref(3)%val(0))
872 16 : field_ref(4)%val = sep
873 4 : allocate(field_ref(5)%val(0))
874 : else
875 8 : allocate(field_ref(1)%val(0))
876 8 : allocate(field_ref(2)%val(0))
877 8 : allocate(field_ref(3)%val(0))
878 : endif
879 : #endif
880 : #elif CK_ENABLED && D1_D1_ENABLED
881 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
882 180 : sep = [(1._CKC,-1._CKC)]
883 : #if CVXK_ENABLED || PVXK_ENABLED
884 12 : if (getOption(.false._LK, keep)) then
885 4 : allocate(field_ref(1)%val(0))
886 16 : field_ref(2)%val = sep
887 4 : allocate(field_ref(3)%val(0))
888 16 : field_ref(4)%val = sep
889 4 : allocate(field_ref(5)%val(0))
890 : else
891 8 : allocate(field_ref(1)%val(0))
892 8 : allocate(field_ref(2)%val(0))
893 8 : allocate(field_ref(3)%val(0))
894 : endif
895 : #endif
896 : #elif RK_ENABLED && D1_D1_ENABLED
897 240 : array = [1._RKC, 1._RKC]
898 180 : sep = [1._RKC]
899 : #if CVXK_ENABLED || PVXK_ENABLED
900 12 : if (getOption(.false._LK, keep)) then
901 4 : allocate(field_ref(1)%val(0))
902 16 : field_ref(2)%val = sep
903 4 : allocate(field_ref(3)%val(0))
904 16 : field_ref(4)%val = sep
905 4 : allocate(field_ref(5)%val(0))
906 : else
907 8 : allocate(field_ref(1)%val(0))
908 8 : allocate(field_ref(2)%val(0))
909 8 : allocate(field_ref(3)%val(0))
910 : endif
911 : #endif
912 : #endif
913 312 : if (getOption(.false._LK, keep)) then
914 104 : allocate(sindex_ref(2,5))
915 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
916 104 : sindex_ref(1,2) = 1; sindex_ref(2,2) = 1
917 104 : sindex_ref(1,3) = 2; sindex_ref(2,3) = 1
918 104 : sindex_ref(1,4) = 2; sindex_ref(2,4) = 2
919 104 : sindex_ref(1,5) = 3; sindex_ref(2,5) = 2
920 : else
921 208 : allocate(sindex_ref(2,3))
922 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
923 208 : sindex_ref(1,2) = 2; sindex_ref(2,2) = 1
924 208 : sindex_ref(1,3) = 3; sindex_ref(2,3) = 2
925 : end if
926 :
927 1560 : instance = [1_IK, -2_IK, -1_IK]
928 :
929 312 : call reportDelim(iseq, keep)
930 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty.", int(__LINE__, IK))
931 :
932 312 : call reportDelim(iseq, keep, instance = instance)
933 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty, redundant, non-unique, and mixed.", int(__LINE__, IK))
934 :
935 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
936 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty, redundant, non-unique, and mixed, with `sorted = .true.`.", int(__LINE__, IK))
937 :
938 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
939 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty, redundant, non-unique, and mixed, with `sorted = .false.`.", int(__LINE__, IK))
940 :
941 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
942 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty, redundant, non-unique, and mixed, with `unique = .false.`.", int(__LINE__, IK))
943 :
944 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
945 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty, redundant, non-unique, and mixed, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
946 :
947 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
948 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty, redundant, non-unique, and mixed, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
949 :
950 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
951 :
952 312 : call reset()
953 :
954 : #if CVXK_ENABLED || PVXK_ENABLED
955 72 : if (getOption(.false._LK, keep)) then
956 144 : allocate(field_ref(5))
957 : else
958 192 : allocate(field_ref(3))
959 : endif
960 : #endif
961 : #if SK_ENABLED && D0_D0_ENABLED
962 24 : array = "AA"
963 24 : sep = "A"
964 : #if CVXK_ENABLED || PVXK_ENABLED
965 12 : if (getOption(.false._LK, keep)) then
966 4 : field_ref(1)%val = ""
967 4 : field_ref(2)%val = sep
968 4 : field_ref(3)%val = ""
969 4 : field_ref(4)%val = sep
970 4 : field_ref(5)%val = ""
971 : else
972 8 : field_ref(1)%val = ""
973 8 : field_ref(2)%val = ""
974 8 : field_ref(3)%val = ""
975 : endif
976 : #endif
977 : #elif SK_ENABLED && D1_D1_ENABLED
978 96 : array = ["AA", "AA"]
979 72 : sep = ["AA"]
980 : #if CVXK_ENABLED || PVXK_ENABLED
981 12 : if (getOption(.false._LK, keep)) then
982 4 : allocate(character(2,SKC) :: field_ref(1)%val(0))
983 16 : field_ref(2)%val = sep
984 4 : allocate(character(2,SKC) :: field_ref(3)%val(0))
985 16 : field_ref(4)%val = sep
986 4 : allocate(character(2,SKC) :: field_ref(5)%val(0))
987 : else
988 8 : allocate(character(2,SKC) :: field_ref(1)%val(0))
989 8 : allocate(character(2,SKC) :: field_ref(2)%val(0))
990 8 : allocate(character(2,SKC) :: field_ref(3)%val(0))
991 : endif
992 : #endif
993 : #elif IK_ENABLED && D1_D1_ENABLED
994 288 : array = [1_IKC, 1_IKC]
995 216 : sep = [1_IKC]
996 : #if CVXK_ENABLED || PVXK_ENABLED
997 12 : if (getOption(.false._LK, keep)) then
998 4 : allocate(field_ref(1)%val(0))
999 16 : field_ref(2)%val = sep
1000 4 : allocate(field_ref(3)%val(0))
1001 16 : field_ref(4)%val = sep
1002 4 : allocate(field_ref(5)%val(0))
1003 : else
1004 8 : allocate(field_ref(1)%val(0))
1005 8 : allocate(field_ref(2)%val(0))
1006 8 : allocate(field_ref(3)%val(0))
1007 : endif
1008 : #endif
1009 : #elif LK_ENABLED && D1_D1_ENABLED
1010 288 : array = [.false._LK, .false._LK]
1011 216 : sep = [.false._LK]
1012 : #if CVXK_ENABLED || PVXK_ENABLED
1013 12 : if (getOption(.false._LK, keep)) then
1014 4 : allocate(field_ref(1)%val(0))
1015 16 : field_ref(2)%val = sep
1016 4 : allocate(field_ref(3)%val(0))
1017 16 : field_ref(4)%val = sep
1018 4 : allocate(field_ref(5)%val(0))
1019 : else
1020 8 : allocate(field_ref(1)%val(0))
1021 8 : allocate(field_ref(2)%val(0))
1022 8 : allocate(field_ref(3)%val(0))
1023 : endif
1024 : #endif
1025 : #elif CK_ENABLED && D1_D1_ENABLED
1026 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1027 180 : sep = [(1._CKC,-1._CKC)]
1028 : #if CVXK_ENABLED || PVXK_ENABLED
1029 12 : if (getOption(.false._LK, keep)) then
1030 4 : allocate(field_ref(1)%val(0))
1031 16 : field_ref(2)%val = sep
1032 4 : allocate(field_ref(3)%val(0))
1033 16 : field_ref(4)%val = sep
1034 4 : allocate(field_ref(5)%val(0))
1035 : else
1036 8 : allocate(field_ref(1)%val(0))
1037 8 : allocate(field_ref(2)%val(0))
1038 8 : allocate(field_ref(3)%val(0))
1039 : endif
1040 : #endif
1041 : #elif RK_ENABLED && D1_D1_ENABLED
1042 240 : array = [1._RKC, 1._RKC]
1043 180 : sep = [1._RKC]
1044 : #if CVXK_ENABLED || PVXK_ENABLED
1045 12 : if (getOption(.false._LK, keep)) then
1046 4 : allocate(field_ref(1)%val(0))
1047 16 : field_ref(2)%val = sep
1048 4 : allocate(field_ref(3)%val(0))
1049 16 : field_ref(4)%val = sep
1050 4 : allocate(field_ref(5)%val(0))
1051 : else
1052 8 : allocate(field_ref(1)%val(0))
1053 8 : allocate(field_ref(2)%val(0))
1054 8 : allocate(field_ref(3)%val(0))
1055 : endif
1056 : #endif
1057 : #endif
1058 312 : if (getOption(.false._LK, keep)) then
1059 104 : allocate(sindex_ref(2,5))
1060 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
1061 104 : sindex_ref(1,2) = 1; sindex_ref(2,2) = 1
1062 104 : sindex_ref(1,3) = 2; sindex_ref(2,3) = 1
1063 104 : sindex_ref(1,4) = 2; sindex_ref(2,4) = 2
1064 104 : sindex_ref(1,5) = 3; sindex_ref(2,5) = 2
1065 : else
1066 208 : allocate(sindex_ref(2,3))
1067 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
1068 208 : sindex_ref(1,2) = 2; sindex_ref(2,2) = 1
1069 208 : sindex_ref(1,3) = 3; sindex_ref(2,3) = 2
1070 : end if
1071 :
1072 1872 : instance = [1_IK, -1_IK, -2_IK, 0_IK]
1073 :
1074 312 : call reportDelim(iseq, keep)
1075 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty.", int(__LINE__, IK))
1076 :
1077 312 : call reportDelim(iseq, keep, instance = instance)
1078 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty, redundant, non-unique, unsorted, and mixed.", int(__LINE__, IK))
1079 :
1080 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1081 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty, redundant, non-unique, unsorted, and mixed, with `sorted = .false.`.", int(__LINE__, IK))
1082 :
1083 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1084 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty, redundant, non-unique, unsorted, and mixed, with `unique = .false.`.", int(__LINE__, IK))
1085 :
1086 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1087 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size `size(array)/size(sep) + 1` whose components are all empty when `instance` is non-empty, redundant, non-unique, unsorted, and mixed, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1088 :
1089 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1090 :
1091 312 : call reset()
1092 :
1093 : #if CVXK_ENABLED || PVXK_ENABLED
1094 72 : if (getOption(.false._LK, keep)) then
1095 96 : allocate(field_ref(3))
1096 : else
1097 144 : allocate(field_ref(2))
1098 : endif
1099 : #endif
1100 : #if SK_ENABLED && D0_D0_ENABLED
1101 24 : array = "AA"
1102 24 : sep = "A"
1103 : #if CVXK_ENABLED || PVXK_ENABLED
1104 12 : if (getOption(.false._LK, keep)) then
1105 4 : field_ref(1)%val = ""
1106 4 : field_ref(2)%val = sep
1107 4 : field_ref(3)%val = "A"
1108 : else
1109 8 : field_ref(1)%val = ""
1110 8 : field_ref(2)%val = "A"
1111 : endif
1112 : #endif
1113 : #elif SK_ENABLED && D1_D1_ENABLED
1114 96 : array = ["AA", "AA"]
1115 72 : sep = ["AA"]
1116 : #if CVXK_ENABLED || PVXK_ENABLED
1117 12 : if (getOption(.false._LK, keep)) then
1118 4 : field_ref(1)%val = [character(2,SKC) ::]
1119 16 : field_ref(2)%val = sep
1120 12 : field_ref(3)%val = ["AA"]
1121 : else
1122 8 : field_ref(1)%val = [character(2,SKC) ::]
1123 24 : field_ref(2)%val = ["AA"]
1124 : endif
1125 : #endif
1126 : #elif IK_ENABLED && D1_D1_ENABLED
1127 288 : array = [1_IKC, 1_IKC]
1128 216 : sep = [1_IKC]
1129 : #if CVXK_ENABLED || PVXK_ENABLED
1130 12 : if (getOption(.false._LK, keep)) then
1131 4 : field_ref(1)%val = [integer(IKC) ::]
1132 16 : field_ref(2)%val = sep
1133 12 : field_ref(3)%val = [1_IKC]
1134 : else
1135 8 : field_ref(1)%val = [integer(IKC) ::]
1136 24 : field_ref(2)%val = [1_IKC]
1137 : endif
1138 : #endif
1139 : #elif LK_ENABLED && D1_D1_ENABLED
1140 288 : array = [.false._LK, .false._LK]
1141 216 : sep = [.false._LK]
1142 : #if CVXK_ENABLED || PVXK_ENABLED
1143 12 : if (getOption(.false._LK, keep)) then
1144 4 : field_ref(1)%val = [logical(LKC) ::]
1145 16 : field_ref(2)%val = sep
1146 12 : field_ref(3)%val = [.false._LKC]
1147 : else
1148 8 : field_ref(1)%val = [logical(LKC) ::]
1149 24 : field_ref(2)%val = [.false._LKC]
1150 : endif
1151 : #endif
1152 : #elif CK_ENABLED && D1_D1_ENABLED
1153 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1154 180 : sep = [(1._CKC,-1._CKC)]
1155 : #if CVXK_ENABLED || PVXK_ENABLED
1156 12 : if (getOption(.false._LK, keep)) then
1157 4 : field_ref(1)%val = [complex(CKC) ::]
1158 16 : field_ref(2)%val = sep
1159 12 : field_ref(3)%val = [(1._CKC,-1._CKC)]
1160 : else
1161 8 : field_ref(1)%val = [complex(CKC) ::]
1162 24 : field_ref(2)%val = [(1._CKC,-1._CKC)]
1163 : endif
1164 : #endif
1165 : #elif RK_ENABLED && D1_D1_ENABLED
1166 240 : array = [1._RKC, 1._RKC]
1167 180 : sep = [1._RKC]
1168 : #if CVXK_ENABLED || PVXK_ENABLED
1169 12 : if (getOption(.false._LK, keep)) then
1170 4 : field_ref(1)%val = [real(RKC) ::]
1171 16 : field_ref(2)%val = sep
1172 12 : field_ref(3)%val = [1._RKC]
1173 : else
1174 8 : field_ref(1)%val = [real(RKC) ::]
1175 24 : field_ref(2)%val = [1._RKC]
1176 : endif
1177 : #endif
1178 : #endif
1179 312 : if (getOption(.false._LK, keep)) then
1180 104 : allocate(sindex_ref(2,3))
1181 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
1182 104 : sindex_ref(1,2) = 1; sindex_ref(2,2) = 1
1183 104 : sindex_ref(1,3) = 2; sindex_ref(2,3) = 2
1184 : else
1185 208 : allocate(sindex_ref(2,2))
1186 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
1187 208 : sindex_ref(1,2) = 2; sindex_ref(2,2) = 2
1188 : end if
1189 :
1190 1248 : instance = [1_IK, -2_IK]
1191 :
1192 312 : call reportDelim(iseq, keep, instance = instance)
1193 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed.", int(__LINE__, IK))
1194 :
1195 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1196 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .true.`.", int(__LINE__, IK))
1197 :
1198 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1199 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .false.`.", int(__LINE__, IK))
1200 :
1201 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1202 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `unique = .false.`.", int(__LINE__, IK))
1203 :
1204 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1205 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1206 :
1207 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1208 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1209 :
1210 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1211 :
1212 312 : call reset()
1213 :
1214 : #if SK_ENABLED && D0_D0_ENABLED
1215 24 : array = "AA"
1216 24 : sep = "A"
1217 : !#if CVXK_ENABLED || PVXK_ENABLED
1218 : ! field_ref(1)%val = ""
1219 : ! field_ref(2)%val = "A"
1220 : !#endif
1221 : #elif SK_ENABLED && D1_D1_ENABLED
1222 96 : array = ["AA", "AA"]
1223 72 : sep = ["AA"]
1224 : !#if CVXK_ENABLED || PVXK_ENABLED
1225 : ! allocate(character(2,SKC) :: field_ref(1)%val(0))
1226 : ! field_ref(2)%val = ["AA"]
1227 : !#endif
1228 : #elif IK_ENABLED && D1_D1_ENABLED
1229 288 : array = [1_IKC, 1_IKC]
1230 216 : sep = [1_IKC]
1231 : !#if CVXK_ENABLED || PVXK_ENABLED
1232 : ! allocate(field_ref(1)%val(0))
1233 : ! field_ref(2)%val = [1_IKC]
1234 : !#endif
1235 : #elif LK_ENABLED && D1_D1_ENABLED
1236 288 : array = [.false._LK, .false._LK]
1237 216 : sep = [.false._LK]
1238 : !#if CVXK_ENABLED || PVXK_ENABLED
1239 : ! allocate(field_ref(1)%val(0))
1240 : ! field_ref(2)%val = [.false._LK]
1241 : !#endif
1242 : #elif CK_ENABLED && D1_D1_ENABLED
1243 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1244 180 : sep = [(1._CKC,-1._CKC)]
1245 : !#if CVXK_ENABLED || PVXK_ENABLED
1246 : ! allocate(field_ref(1)%val(0))
1247 : ! field_ref(2)%val = [(1._CKC,-1._CKC)]
1248 : !#endif
1249 : #elif RK_ENABLED && D1_D1_ENABLED
1250 240 : array = [1._RKC, 1._RKC]
1251 180 : sep = [1._RKC]
1252 : !#if CVXK_ENABLED || PVXK_ENABLED
1253 : ! allocate(field_ref(1)%val(0))
1254 : ! field_ref(2)%val = [1._RKC]
1255 : !#endif
1256 : #endif
1257 936 : instance = [-2_IK]
1258 : #if CVXK_ENABLED || PVXK_ENABLED
1259 72 : if (getOption(.false._LK, keep)) then
1260 96 : allocate(field_ref(3))
1261 24 : field_ref(1)%val = array(1:0)
1262 64 : field_ref(2)%val = array(1:1)
1263 64 : field_ref(3)%val = array(2:2)
1264 : else
1265 144 : allocate(field_ref(2))
1266 48 : field_ref(1)%val = array(1:0)
1267 128 : field_ref(2)%val = array(2:2)
1268 : endif
1269 : #endif
1270 312 : if (getOption(.false._LK, keep)) then
1271 104 : allocate(sindex_ref(2,3))
1272 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
1273 104 : sindex_ref(1,2) = 1; sindex_ref(2,2) = 1
1274 104 : sindex_ref(1,3) = 2; sindex_ref(2,3) = 2
1275 : else
1276 208 : allocate(sindex_ref(2,2))
1277 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
1278 208 : sindex_ref(1,2) = 2; sindex_ref(2,2) = 2
1279 : endif
1280 :
1281 312 : call reportDelim(iseq, keep, instance = instance)
1282 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive and unique.", int(__LINE__, IK))
1283 :
1284 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1285 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive and unique, with `sorted = .true.`.", int(__LINE__, IK))
1286 :
1287 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1288 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive and unique, with `sorted = .false.`.", int(__LINE__, IK))
1289 :
1290 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1291 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive and unique, with `unique = .true.`.", int(__LINE__, IK))
1292 :
1293 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1294 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive and unique, with `unique = .false.`.", int(__LINE__, IK))
1295 :
1296 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1297 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive and unique, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1298 :
1299 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1300 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive and unique, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1301 :
1302 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1303 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose first component is empty but the last corresponds to the last element of `array` when `instance` is non-empty but incomprehensive and unique, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1304 :
1305 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1306 :
1307 312 : call reset()
1308 :
1309 : #if SK_ENABLED && D0_D0_ENABLED
1310 24 : array = "AA"
1311 24 : sep = "A"
1312 : !#if CVXK_ENABLED || PVXK_ENABLED
1313 : ! field_ref(1)%val = "A"
1314 : ! field_ref(2)%val = ""
1315 : !#endif
1316 : #elif SK_ENABLED && D1_D1_ENABLED
1317 96 : array = ["AA", "AA"]
1318 72 : sep = ["AA"]
1319 : !#if CVXK_ENABLED || PVXK_ENABLED
1320 : ! field_ref(1)%val = ["AA"]
1321 : ! allocate(character(2,SKC) :: field_ref(2)%val(0))
1322 : !#endif
1323 : #elif IK_ENABLED && D1_D1_ENABLED
1324 288 : array = [1_IKC, 1_IKC]
1325 216 : sep = [1_IKC]
1326 : !#if CVXK_ENABLED || PVXK_ENABLED
1327 : ! field_ref(1)%val = [1_IKC]
1328 : ! allocate(field_ref(2)%val(0))
1329 : !#endif
1330 : #elif LK_ENABLED && D1_D1_ENABLED
1331 288 : array = [.false._LK, .false._LK]
1332 216 : sep = [.false._LK]
1333 : !#if CVXK_ENABLED || PVXK_ENABLED
1334 : ! field_ref(1)%val = [.false._LK]
1335 : ! allocate(field_ref(2)%val(0))
1336 : !#endif
1337 : #elif CK_ENABLED && D1_D1_ENABLED
1338 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1339 180 : sep = [(1._CKC,-1._CKC)]
1340 : !#if CVXK_ENABLED || PVXK_ENABLED
1341 : ! field_ref(1)%val = [(1._CKC,-1._CKC)]
1342 : ! allocate(field_ref(2)%val(0))
1343 : !#endif
1344 : #elif RK_ENABLED && D1_D1_ENABLED
1345 240 : array = [1._RKC, 1._RKC]
1346 180 : sep = [1._RKC]
1347 : !#if CVXK_ENABLED || PVXK_ENABLED
1348 : ! field_ref(1)%val = [1._RKC]
1349 : ! allocate(field_ref(2)%val(0))
1350 : !#endif
1351 : #endif
1352 1248 : instance = [-1_IK, 3_IK]
1353 : #if CVXK_ENABLED || PVXK_ENABLED
1354 72 : if (getOption(.false._LK, keep)) then
1355 96 : allocate(field_ref(3))
1356 64 : field_ref(1)%val = array(1:1)
1357 64 : field_ref(2)%val = array(2:2)
1358 24 : field_ref(3)%val = array(3:2)
1359 : else
1360 144 : allocate(field_ref(2))
1361 128 : field_ref(1)%val = array(1:1)
1362 48 : field_ref(2)%val = array(3:2)
1363 : endif
1364 : #endif
1365 312 : if (getOption(.false._LK, keep)) then
1366 104 : allocate(sindex_ref(2,3))
1367 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 1
1368 104 : sindex_ref(1,2) = 2; sindex_ref(2,2) = 2
1369 104 : sindex_ref(1,3) = 3; sindex_ref(2,3) = 2
1370 : else
1371 208 : allocate(sindex_ref(2,2))
1372 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 1
1373 208 : sindex_ref(1,2) = 3; sindex_ref(2,2) = 2
1374 : endif
1375 :
1376 312 : call reportDelim(iseq, keep, instance = instance)
1377 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose last component is empty but the first corresponds to the first element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed.", int(__LINE__, IK))
1378 :
1379 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1380 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose last component is empty but the first corresponds to the first element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .true.`.", int(__LINE__, IK))
1381 :
1382 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1383 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose last component is empty but the first corresponds to the first element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .false.`.", int(__LINE__, IK))
1384 :
1385 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1386 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose last component is empty but the first corresponds to the first element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `unique = .true.`.", int(__LINE__, IK))
1387 :
1388 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1389 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose last component is empty but the first corresponds to the first element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `unique = .false.`.", int(__LINE__, IK))
1390 :
1391 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1392 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose last component is empty but the first corresponds to the first element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1393 :
1394 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1395 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose last component is empty but the first corresponds to the first element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1396 :
1397 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1398 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` of non-empty `sep` must yield an `field` of size two whose last component is empty but the first corresponds to the first element of `array` when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1399 :
1400 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1401 :
1402 312 : call reset()
1403 :
1404 : #if SK_ENABLED && D0_D0_ENABLED
1405 24 : array = "AA"
1406 : !#if CVXK_ENABLED || PVXK_ENABLED
1407 : ! field_ref(1)%val = ""
1408 : ! field_ref(2)%val = ""
1409 : !#endif
1410 : #elif SK_ENABLED && D1_D1_ENABLED
1411 96 : array = ["AA", "AA"]
1412 : !#if CVXK_ENABLED || PVXK_ENABLED
1413 : ! allocate(character(2,SKC) :: field_ref(1)%val(0))
1414 : ! allocate(character(2,SKC) :: field_ref(2)%val(0))
1415 : !#endif
1416 : #elif IK_ENABLED && D1_D1_ENABLED
1417 288 : array = [1_IKC, 1_IKC]
1418 : !#if CVXK_ENABLED || PVXK_ENABLED
1419 : ! allocate(field_ref(1)%val(0))
1420 : ! allocate(field_ref(2)%val(0))
1421 : !#endif
1422 : #elif LK_ENABLED && D1_D1_ENABLED
1423 288 : array = [.false._LK, .false._LK]
1424 : !#if CVXK_ENABLED || PVXK_ENABLED
1425 : ! allocate(field_ref(1)%val(0))
1426 : ! allocate(field_ref(2)%val(0))
1427 : !#endif
1428 : #elif CK_ENABLED && D1_D1_ENABLED
1429 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1430 : !#if CVXK_ENABLED || PVXK_ENABLED
1431 : ! allocate(field_ref(1)%val(0))
1432 : ! allocate(field_ref(2)%val(0))
1433 : !#endif
1434 : #elif RK_ENABLED && D1_D1_ENABLED
1435 240 : array = [1._RKC, 1._RKC]
1436 : !#if CVXK_ENABLED || PVXK_ENABLED
1437 : ! allocate(field_ref(1)%val(0))
1438 : ! allocate(field_ref(2)%val(0))
1439 : !#endif
1440 : #endif
1441 1464 : sep = array
1442 1248 : instance = [-1_IK, 3_IK]
1443 :
1444 : #if CVXK_ENABLED || PVXK_ENABLED
1445 72 : if (getOption(.false._LK, keep)) then
1446 96 : allocate(field_ref(3))
1447 24 : field_ref(1)%val = array(1:0)
1448 84 : field_ref(2)%val = array(1:GET_SIZE(array)) ! fpp
1449 44 : field_ref(3)%val = array(GET_SIZE(array)+1:GET_SIZE(array)) ! fpp
1450 : else
1451 144 : allocate(field_ref(2))
1452 48 : field_ref(1)%val = array(1:0)
1453 88 : field_ref(2)%val = array(GET_SIZE(array):GET_SIZE(array)-1) ! fpp
1454 : endif
1455 : #endif
1456 312 : if (getOption(.false._LK, keep)) then
1457 104 : allocate(sindex_ref(2,3))
1458 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
1459 104 : sindex_ref(1,2) = 1; sindex_ref(2,2) = GET_SIZE(array) ! fpp
1460 104 : sindex_ref(1,3) = GET_SIZE(array); sindex_ref(2,3) = GET_SIZE(array) - 1 ! fpp
1461 : else
1462 208 : allocate(sindex_ref(2,2))
1463 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
1464 208 : sindex_ref(1,2) = GET_SIZE(array); sindex_ref(2,2) = GET_SIZE(array) - 1 ! fpp
1465 : endif
1466 :
1467 312 : call reportDelim(iseq, keep, instance = instance)
1468 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed.", int(__LINE__, IK))
1469 :
1470 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1471 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .true.`.", int(__LINE__, IK))
1472 :
1473 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1474 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .false.`.", int(__LINE__, IK))
1475 :
1476 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1477 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `unique = .true.`.", int(__LINE__, IK))
1478 :
1479 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1480 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `unique = .false.`.", int(__LINE__, IK))
1481 :
1482 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1483 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1484 :
1485 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1486 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1487 :
1488 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1489 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is non-empty but incomprehensive, redundant, non-unique, and mixed, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1490 :
1491 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1492 :
1493 312 : call reset()
1494 :
1495 : #if SK_ENABLED && D0_D0_ENABLED
1496 24 : array = "AA"
1497 : #elif SK_ENABLED && D1_D1_ENABLED
1498 96 : array = ["AA", "AA"]
1499 : #elif IK_ENABLED && D1_D1_ENABLED
1500 288 : array = [1_IKC, 1_IKC]
1501 : #elif LK_ENABLED && D1_D1_ENABLED
1502 288 : array = [.false._LK, .false._LK]
1503 : #elif CK_ENABLED && D1_D1_ENABLED
1504 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1505 : #elif RK_ENABLED && D1_D1_ENABLED
1506 240 : array = [1._RKC, 1._RKC]
1507 : #endif
1508 1464 : sep = array
1509 1248 : instance = [0_IK, 3_IK]
1510 : #if CVXK_ENABLED || PVXK_ENABLED
1511 168 : allocate(field_ref(1))
1512 312 : field_ref(1)%val = array
1513 : #endif
1514 312 : allocate(sindex_ref(2,1))
1515 312 : sindex_ref(1,1) = 1; sindex_ref(2,1) = GET_SIZE(array) ! fpp
1516 :
1517 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1518 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true.`.", int(__LINE__, IK))
1519 :
1520 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1521 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .false.`.", int(__LINE__, IK))
1522 :
1523 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1524 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `unique = .true.`.", int(__LINE__, IK))
1525 :
1526 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1527 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `unique = .false.`.", int(__LINE__, IK))
1528 :
1529 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1530 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1531 :
1532 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1533 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1534 :
1535 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1536 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` the same as the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1537 :
1538 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1539 :
1540 312 : call reset()
1541 :
1542 : #if SK_ENABLED && D0_D0_ENABLED
1543 24 : array = "AA"
1544 24 : sep = array//array
1545 : #elif SK_ENABLED && D1_D1_ENABLED
1546 96 : array = ["AA", "AA"]
1547 240 : sep = [array, array]
1548 : #elif IK_ENABLED && D1_D1_ENABLED
1549 288 : array = [1_IKC, 1_IKC]
1550 720 : sep = [array, array]
1551 : #elif LK_ENABLED && D1_D1_ENABLED
1552 288 : array = [.false._LK, .false._LK]
1553 720 : sep = [array, array]
1554 : #elif CK_ENABLED && D1_D1_ENABLED
1555 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1556 600 : sep = [array, array]
1557 : #elif RK_ENABLED && D1_D1_ENABLED
1558 240 : array = [1._RKC, 1._RKC]
1559 600 : sep = [array, array]
1560 : #endif
1561 1248 : instance = [0_IK, 3_IK]
1562 : #if CVXK_ENABLED || PVXK_ENABLED
1563 168 : allocate(field_ref(1))
1564 312 : field_ref(1)%val = array
1565 : #endif
1566 312 : allocate(sindex_ref(2,1))
1567 312 : sindex_ref(1,1) = 1; sindex_ref(2,1) = GET_SIZE(array) ! fpp
1568 :
1569 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1570 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true.`.", int(__LINE__, IK))
1571 :
1572 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1573 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .false.`.", int(__LINE__, IK))
1574 :
1575 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1576 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `unique = .true.`.", int(__LINE__, IK))
1577 :
1578 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1579 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `unique = .false.`.", int(__LINE__, IK))
1580 :
1581 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1582 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1583 :
1584 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1585 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1586 :
1587 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1588 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1589 :
1590 936 : instance = [1_IK]
1591 :
1592 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1593 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .true.`.", int(__LINE__, IK))
1594 :
1595 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1596 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .false.`.", int(__LINE__, IK))
1597 :
1598 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1599 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty, and sensible, with `unique = .true.`.", int(__LINE__, IK))
1600 :
1601 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1602 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty, and sensible, with `unique = .false.`.", int(__LINE__, IK))
1603 :
1604 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1605 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1606 :
1607 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1608 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1609 :
1610 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1611 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` larger than the `array` must yield an `field` of size two whose components are all empty when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1612 :
1613 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1614 :
1615 312 : call reset()
1616 :
1617 : #if SK_ENABLED && D0_D0_ENABLED
1618 24 : array = "AABBCCAA"
1619 24 : sep = "AA"
1620 : #elif SK_ENABLED && D1_D1_ENABLED
1621 240 : array = ["AA", "AA", "BB", "BB", "CC", "CC", "AA", "AA"]
1622 96 : sep = ["AA", "AA"]
1623 : !#if CVXK_ENABLED || PVXK_ENABLED
1624 : ! allocate(character(2,SKC) :: field_ref(1)%val(0))
1625 : ! allocate(character(2,SKC) :: field_ref(3)%val(0))
1626 : ! field_ref(2)%val = ["BB", "CC"]
1627 : !#endif
1628 : #elif IK_ENABLED && D1_D1_ENABLED
1629 720 : array = [1_IKC, 1_IKC, 2_IKC, 2_IKC, 3_IKC, 3_IKC, 1_IKC, 1_IKC]
1630 288 : sep = [1_IKC, 1_IKC]
1631 : !#if CVXK_ENABLED || PVXK_ENABLED
1632 : ! allocate(field_ref(1)%val(0))
1633 : ! field_ref(2)%val = [2_IKC, 2_IKC, 3_IKC, 3_IKC]
1634 : ! allocate(field_ref(3)%val(0))
1635 : !#endif
1636 : #elif LK_ENABLED && D1_D1_ENABLED
1637 720 : array = [.false._LK, .false._LK, .true._LK, .true._LK, .true._LK, .true._LK, .false._LK, .false._LK]
1638 288 : sep = [.false._LK, .false._LK]
1639 : !#if CVXK_ENABLED || PVXK_ENABLED
1640 : ! allocate(field_ref(1)%val(0))
1641 : ! field_ref(2)%val = [.true._LK, .true._LK, .true._LK, .true._LK]
1642 : ! allocate(field_ref(3)%val(0))
1643 : !#endif
1644 : #elif CK_ENABLED && D1_D1_ENABLED
1645 600 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC), (2._CKC,-2._CKC), (2._CKC,-2._CKC), (3._CKC,-3._CKC), (3._CKC,-3._CKC), (1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1646 240 : sep = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1647 : !#if CVXK_ENABLED || PVXK_ENABLED
1648 : ! allocate(field_ref(1)%val(0))
1649 : ! field_ref(2)%val = [(2._CKC,-2._CKC), (2._CKC,-2._CKC), (3._CKC,-3._CKC), (3._CKC,-3._CKC)]
1650 : ! allocate(field_ref(3)%val(0))
1651 : !#endif
1652 : #elif RK_ENABLED && D1_D1_ENABLED
1653 600 : array = [1._RKC, 1._RKC, 2._RKC, 2._RKC, 3._RKC, 3._RKC, 1._RKC, 1._RKC]
1654 240 : sep = [1._RKC, 1._RKC]
1655 : !#if CVXK_ENABLED || PVXK_ENABLED
1656 : ! allocate(field_ref(1)%val(0))
1657 : ! field_ref(2)%val = [2._RKC, 2._RKC, 3._RKC, 3._RKC]
1658 : ! allocate(field_ref(3)%val(0))
1659 : !#endif
1660 : #endif
1661 : #if CVXK_ENABLED || PVXK_ENABLED
1662 72 : if (getOption(.false._LK, keep)) then
1663 144 : allocate(field_ref(5))
1664 24 : field_ref(1)%val = array(1:0)
1665 84 : field_ref(2)%val = array(1:2)
1666 124 : field_ref(3)%val = array(3:6)
1667 84 : field_ref(4)%val = array(7:8)
1668 24 : field_ref(5)%val = array(9:8)
1669 : else
1670 192 : allocate(field_ref(3))
1671 48 : field_ref(1)%val = array(1:0)
1672 248 : field_ref(2)%val = array(3:6)
1673 48 : field_ref(3)%val = array(8:7)
1674 : endif
1675 : #endif
1676 312 : if (getOption(.false._LK, keep)) then
1677 104 : allocate(sindex_ref(2,5))
1678 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
1679 104 : sindex_ref(1,2) = 1; sindex_ref(2,2) = 2
1680 104 : sindex_ref(1,3) = 3; sindex_ref(2,3) = 6
1681 104 : sindex_ref(1,4) = 7; sindex_ref(2,4) = 8
1682 104 : sindex_ref(1,5) = 9; sindex_ref(2,5) = 8
1683 : else
1684 208 : allocate(sindex_ref(2,3))
1685 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 0
1686 208 : sindex_ref(1,2) = 3; sindex_ref(2,2) = 6
1687 208 : sindex_ref(1,3) = 9; sindex_ref(2,3) = 8
1688 : endif
1689 1248 : instance = [1_IK, -1_IK]
1690 :
1691 312 : call reportDelim(iseq, keep)
1692 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` occurrence at the beginning and the end of the `array` must yield an `field` of size three whose first and last elements are empty.", int(__LINE__, IK))
1693 :
1694 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1695 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` occurrence at the beginning and the end of the `array` must yield an `field` of size three whose first and last elements are empty when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .true.`.", int(__LINE__, IK))
1696 :
1697 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1698 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` occurrence at the beginning and the end of the `array` must yield an `field` of size three whose first and last elements are empty when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .false.`.", int(__LINE__, IK))
1699 :
1700 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1701 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` occurrence at the beginning and the end of the `array` must yield an `field` of size three whose first and last elements are empty when `instance` is ordered, unique, non-empty, and sensible, with `unique = .true.`.", int(__LINE__, IK))
1702 :
1703 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1704 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` occurrence at the beginning and the end of the `array` must yield an `field` of size three whose first and last elements are empty when `instance` is ordered, unique, non-empty, and sensible, with `unique = .false.`.", int(__LINE__, IK))
1705 :
1706 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1707 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` occurrence at the beginning and the end of the `array` must yield an `field` of size three whose first and last elements are empty when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1708 :
1709 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1710 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` occurrence at the beginning and the end of the `array` must yield an `field` of size three whose first and last elements are empty when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1711 :
1712 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1713 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `sep` occurrence at the beginning and the end of the `array` must yield an `field` of size three whose first and last elements are empty when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1714 :
1715 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1716 :
1717 312 : call reset()
1718 :
1719 : #if SK_ENABLED && D0_D0_ENABLED
1720 24 : array = "AA"
1721 24 : sep = "X"
1722 : #elif SK_ENABLED && D1_D1_ENABLED
1723 96 : array = ["AA", "AA"]
1724 72 : sep = ["XX"]
1725 : #elif IK_ENABLED && D1_D1_ENABLED
1726 288 : array = [1_IKC, 1_IKC]
1727 216 : sep = [0_IKC]
1728 : #elif LK_ENABLED && D1_D1_ENABLED
1729 288 : array = [.false._LK, .false._LK]
1730 216 : sep = [.true._LK]
1731 : #elif CK_ENABLED && D1_D1_ENABLED
1732 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1733 180 : sep = [(0._CKC,0._CKC)]
1734 : #elif RK_ENABLED && D1_D1_ENABLED
1735 240 : array = [1._RKC, 1._RKC]
1736 180 : sep = [0._RKC]
1737 : #endif
1738 1248 : instance = [0_IK, 3_IK]
1739 : #if CVXK_ENABLED || PVXK_ENABLED
1740 168 : allocate(field_ref(1))
1741 312 : field_ref(1)%val = array
1742 : #endif
1743 312 : allocate(sindex_ref(2,1))
1744 312 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 2
1745 :
1746 312 : call reportDelim(iseq, keep)
1747 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array`.", int(__LINE__, IK))
1748 :
1749 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1750 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true.`.", int(__LINE__, IK))
1751 :
1752 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1753 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .false.`.", int(__LINE__, IK))
1754 :
1755 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1756 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `unique = .true.`.", int(__LINE__, IK))
1757 :
1758 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1759 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `unique = .false.`.", int(__LINE__, IK))
1760 :
1761 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1762 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1763 :
1764 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1765 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1766 :
1767 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1768 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1769 :
1770 936 : instance = [1_IK]
1771 :
1772 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1773 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .true.`.", int(__LINE__, IK))
1774 :
1775 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1776 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .false.`.", int(__LINE__, IK))
1777 :
1778 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1779 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty, and sensible, with `unique = .true.`.", int(__LINE__, IK))
1780 :
1781 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1782 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty, and sensible, with `unique = .false.`.", int(__LINE__, IK))
1783 :
1784 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1785 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1786 :
1787 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1788 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1789 :
1790 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1791 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty, and sensible, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1792 :
1793 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1794 :
1795 312 : call reset()
1796 :
1797 : #if SK_ENABLED && D0_D0_ENABLED
1798 24 : array = "AXAXA"
1799 24 : sep = "X"
1800 : #elif SK_ENABLED && D1_D1_ENABLED
1801 168 : array = ["AA", "XX", "AA", "XX", "AA"]
1802 72 : sep = ["XX"]
1803 : #elif IK_ENABLED && D1_D1_ENABLED
1804 504 : array = [1_IKC, 0_IKC, 1_IKC, 0_IKC, 1_IKC]
1805 216 : sep = [0_IKC]
1806 : #elif LK_ENABLED && D1_D1_ENABLED
1807 504 : array = [.false._LK, .true._LK, .false._LK, .true._LK, .false._LK]
1808 216 : sep = [.true._LK]
1809 : #elif CK_ENABLED && D1_D1_ENABLED
1810 420 : array = [(1._CKC,-1._CKC), (0._CKC,0._CKC), (1._CKC,-1._CKC), (0._CKC,0._CKC), (1._CKC,-1._CKC)]
1811 180 : sep = [(0._CKC,0._CKC)]
1812 : #elif RK_ENABLED && D1_D1_ENABLED
1813 420 : array = [1._RKC, 0._RKC, 1._RKC, 0._RKC, 1._RKC]
1814 180 : sep = [0._RKC]
1815 : #endif
1816 1248 : instance = [1_IK, -1_IK]
1817 : #if CVXK_ENABLED || PVXK_ENABLED
1818 72 : if (getOption(.false._LK, keep)) then
1819 144 : allocate(field_ref(5))
1820 64 : field_ref(1)%val = array(1:1)
1821 64 : field_ref(2)%val = array(2:2)
1822 64 : field_ref(3)%val = array(3:3)
1823 64 : field_ref(4)%val = array(4:4)
1824 64 : field_ref(5)%val = array(5:5)
1825 : else
1826 192 : allocate(field_ref(3))
1827 128 : field_ref(1)%val = array(1:1)
1828 128 : field_ref(2)%val = array(3:3)
1829 128 : field_ref(3)%val = array(5:5)
1830 : endif
1831 : #endif
1832 312 : if (getOption(.false._LK, keep)) then
1833 104 : allocate(sindex_ref(2,5))
1834 104 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 1
1835 104 : sindex_ref(1,2) = 2; sindex_ref(2,2) = 2
1836 104 : sindex_ref(1,3) = 3; sindex_ref(2,3) = 3
1837 104 : sindex_ref(1,4) = 4; sindex_ref(2,4) = 4
1838 104 : sindex_ref(1,5) = 5; sindex_ref(2,5) = 5
1839 : else
1840 208 : allocate(sindex_ref(2,3))
1841 208 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 1
1842 208 : sindex_ref(1,2) = 3; sindex_ref(2,2) = 3
1843 208 : sindex_ref(1,3) = 5; sindex_ref(2,3) = 5
1844 : end if
1845 :
1846 312 : call reportDelim(iseq, keep)
1847 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `sep` occurrences must yield an `field` of size three whose three components are the non-matching elements of `array`.", int(__LINE__, IK))
1848 :
1849 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1850 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `sep` occurrences must yield an `field` of size three whose three components are the non-matching elements of `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true.`.", int(__LINE__, IK))
1851 :
1852 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1853 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `sep` occurrences must yield an `field` of size three whose three components are the non-matching elements of `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .false.`.", int(__LINE__, IK))
1854 :
1855 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1856 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `sep` occurrences must yield an `field` of size three whose three components are the non-matching elements of `array` when `instance` is ordered, unique, non-empty but non-sensible, with `unique = .true.`.", int(__LINE__, IK))
1857 :
1858 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1859 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `sep` occurrences must yield an `field` of size three whose three components are the non-matching elements of `array` when `instance` is ordered, unique, non-empty but non-sensible, with `unique = .false.`.", int(__LINE__, IK))
1860 :
1861 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1862 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `sep` occurrences must yield an `field` of size three whose three components are the non-matching elements of `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1863 :
1864 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1865 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `sep` occurrences must yield an `field` of size three whose three components are the non-matching elements of `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1866 :
1867 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1868 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `sep` occurrences must yield an `field` of size three whose three components are the non-matching elements of `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1869 :
1870 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1871 :
1872 312 : call reset()
1873 :
1874 : #if SK_ENABLED && D0_D0_ENABLED
1875 24 : array = "AA"
1876 24 : sep = "A"
1877 : #elif SK_ENABLED && D1_D1_ENABLED
1878 96 : array = ["AA", "AA"]
1879 72 : sep = ["AA"]
1880 : #elif IK_ENABLED && D1_D1_ENABLED
1881 288 : array = [1_IKC, 1_IKC]
1882 216 : sep = [1_IKC]
1883 : #elif LK_ENABLED && D1_D1_ENABLED
1884 288 : array = [.false._LK, .false._LK]
1885 216 : sep = [.false._LK]
1886 : #elif CK_ENABLED && D1_D1_ENABLED
1887 240 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1888 180 : sep = [(1._CKC,-1._CKC)]
1889 : #elif RK_ENABLED && D1_D1_ENABLED
1890 240 : array = [1._RKC, 1._RKC]
1891 180 : sep = [1._RKC]
1892 : #endif
1893 1248 : instance = [0_IK, 3_IK]
1894 : #if CVXK_ENABLED || PVXK_ENABLED
1895 168 : allocate(field_ref(1))
1896 312 : field_ref(1)%val = array
1897 : #endif
1898 312 : allocate(sindex_ref(2,1))
1899 312 : sindex_ref(1,1) = 1; sindex_ref(2,1) = 2
1900 :
1901 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK)
1902 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true.`.", int(__LINE__, IK))
1903 :
1904 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK)
1905 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .false.`.", int(__LINE__, IK))
1906 :
1907 312 : call reportDelim(iseq, keep, instance = instance, unique = .true._LK)
1908 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `unique = .true.`.", int(__LINE__, IK))
1909 :
1910 312 : call reportDelim(iseq, keep, instance = instance, unique = .false._LK)
1911 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `unique = .false.`.", int(__LINE__, IK))
1912 :
1913 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .false._LK)
1914 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true._LK, unique = .false.`.", int(__LINE__, IK))
1915 :
1916 312 : call reportDelim(iseq, keep, instance = instance, sorted = .true._LK, unique = .true._LK)
1917 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .true._LK, unique = .true.`.", int(__LINE__, IK))
1918 :
1919 312 : call reportDelim(iseq, keep, instance = instance, sorted = .false._LK, unique = .false._LK)
1920 312 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `sep` must yield an `field` of size one whose sole component is `array` when `instance` is ordered, unique, non-empty but non-sensible, with `sorted = .false._LK, unique = .false.`.", int(__LINE__, IK))
1921 :
1922 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1923 :
1924 312 : end subroutine
1925 :
1926 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1927 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1928 :
1929 : subroutine reportDelim ( iseq & ! LCOV_EXCL_LINE
1930 : , keep & ! LCOV_EXCL_LINE
1931 : , instance & ! LCOV_EXCL_LINE
1932 : , sorted & ! LCOV_EXCL_LINE
1933 : , unique & ! LCOV_EXCL_LINE
1934 : )
1935 : use pm_io, only: display_type
1936 : logical(LK) , external , optional :: iseq
1937 : logical(LK) , intent(in), optional :: keep
1938 : integer(IK) , intent(in), optional, contiguous :: instance(:)
1939 : logical(LK) , intent(in), optional :: sorted
1940 : logical(LK) , intent(in), optional :: unique
1941 50232 : type(display_type) :: disp
1942 : #if CVXK_ENABLED || PVXK_ENABLED
1943 : integer(IK) :: i
1944 : #endif
1945 :
1946 50232 : disp = display_type()
1947 :
1948 50232 : if (present(iseq) .and. present(instance) .and. present(sorted) .and. present(unique)) then
1949 9672 : call setSplit(sindex, array, sep, iseq = iseq, instance = instance, sorted = sorted, unique = unique, keep = keep)
1950 : #if CVXK_ENABLED || PVXK_ENABLED
1951 7008 : call setSplit(field, array, sep, iseq = iseq, instance = instance, sorted = sorted, unique = unique, keep = keep)
1952 : #endif
1953 40560 : elseif (present(iseq) .and. present(instance) .and. present(sorted) .and. .not. present(unique)) then
1954 6084 : call setSplit(sindex, array, sep, iseq = iseq, instance = instance, sorted = sorted, keep = keep)
1955 : #if CVXK_ENABLED || PVXK_ENABLED
1956 4332 : call setSplit(field, array, sep, iseq = iseq, instance = instance, sorted = sorted, keep = keep)
1957 : #endif
1958 34476 : elseif (present(iseq) .and. present(instance) .and. .not. present(sorted) .and. present(unique)) then
1959 5772 : call setSplit(sindex, array, sep, iseq = iseq, instance = instance, unique = unique, keep = keep)
1960 : #if CVXK_ENABLED || PVXK_ENABLED
1961 4152 : call setSplit(field, array, sep, iseq = iseq, instance = instance, unique = unique, keep = keep)
1962 : #endif
1963 28704 : elseif (present(iseq) .and. present(instance) .and. .not. present(sorted) .and. .not. present(unique)) then
1964 1872 : call setSplit(sindex, array, sep, iseq = iseq, instance = instance, keep = keep)
1965 : #if CVXK_ENABLED || PVXK_ENABLED
1966 1200 : call setSplit(field, array, sep, iseq = iseq, instance = instance, keep = keep)
1967 : #endif
1968 28548 : elseif (present(iseq) .and. .not. present(instance) .and. .not. present(sorted) .and. .not. present(unique)) then
1969 1716 : call setSplit(sindex, array, sep, iseq = iseq, keep = keep)
1970 : #if CVXK_ENABLED || PVXK_ENABLED
1971 396 : call setSplit(field, array, sep, iseq = iseq, keep = keep)
1972 : #endif
1973 25116 : elseif (.not. present(iseq) .and. present(instance) .and. present(sorted) .and. present(unique)) then
1974 9672 : call setSplit(sindex, array, sep, instance = instance, sorted = sorted, unique = unique, keep = keep)
1975 : #if CVXK_ENABLED || PVXK_ENABLED
1976 7008 : call setSplit(field, array, sep, instance = instance, sorted = sorted, unique = unique, keep = keep)
1977 : #endif
1978 15444 : elseif (.not. present(iseq) .and. present(instance) .and. present(sorted) .and. .not. present(unique)) then
1979 6084 : call setSplit(sindex, array, sep, instance = instance, sorted = sorted, keep = keep)
1980 : #if CVXK_ENABLED || PVXK_ENABLED
1981 4332 : call setSplit(field, array, sep, instance = instance, sorted = sorted, keep = keep)
1982 : #endif
1983 9360 : elseif (.not. present(iseq) .and. present(instance) .and. .not. present(sorted) .and. present(unique)) then
1984 5772 : call setSplit(sindex, array, sep, instance = instance, unique = unique, keep = keep)
1985 : #if CVXK_ENABLED || PVXK_ENABLED
1986 4152 : call setSplit(field, array, sep, instance = instance, unique = unique, keep = keep)
1987 : #endif
1988 3588 : elseif (.not. present(iseq) .and. present(instance) .and. .not. present(sorted) .and. .not. present(unique)) then
1989 1872 : call setSplit(sindex, array, sep, instance = instance, keep = keep)
1990 : #if CVXK_ENABLED || PVXK_ENABLED
1991 1200 : call setSplit(field, array, sep, instance = instance, keep = keep)
1992 : #endif
1993 3432 : elseif (.not. present(iseq) .and. .not. present(instance) .and. .not. present(sorted) .and. .not. present(unique)) then
1994 1716 : call setSplit(sindex, array, sep, keep = keep)
1995 : #if CVXK_ENABLED || PVXK_ENABLED
1996 396 : call setSplit(field, array, sep, keep = keep)
1997 : #endif
1998 : else
1999 : error stop PROCEDURE_NAME//SK_": Unrecognized interface in testing." ! LCOV_EXCL_LINE
2000 : end if
2001 :
2002 : ! Report test results if needed.
2003 :
2004 : #if CVXK_ENABLED || PVXK_ENABLED
2005 37200 : do i = 1, size(field_ref)
2006 52840 : assertion = assertion .and. ALL(field(i)%val IS_EQUAL field_ref(i)%val) ! fpp
2007 : end do
2008 : #endif
2009 383136 : assertion = assertion .and. all(sindex == sindex_ref)
2010 50232 : if (test%traceable .and. .not. assertion) then
2011 :
2012 : ! LCOV_EXCL_START
2013 : write(test%disp%unit,"(*(g0,:,', '))")
2014 :
2015 : call disp%show("sep")
2016 : call disp%show( sep )
2017 : call disp%show("array")
2018 : call disp%show( array )
2019 : call disp%show("sindex")
2020 : call disp%show( sindex )
2021 : call disp%show("sindex_ref")
2022 : call disp%show( sindex_ref )
2023 : #if CVXK_ENABLED || PVXK_ENABLED
2024 : call disp%show("field")
2025 : call disp%show( field )
2026 : call disp%show("field_ref")
2027 : call disp%show( field_ref )
2028 : #endif
2029 : write(test%disp%unit,"(*(g0,:,', '))") "present(instance) ", present(instance)
2030 : write(test%disp%unit,"(*(g0,:,', '))") "present(unique) ", present(unique)
2031 : write(test%disp%unit,"(*(g0,:,', '))") "present(sorted) ", present(sorted)
2032 : write(test%disp%unit,"(*(g0,:,', '))") "present(keep) ", present(keep)
2033 : write(test%disp%unit,"(*(g0,:,', '))") "present(iseq) ", present(iseq)
2034 :
2035 : if (present(instance)) then
2036 : write(test%disp%unit,"(*(g0,:,', '))") "instance ", instance
2037 : end if
2038 :
2039 : if (present(sorted)) then
2040 : write(test%disp%unit,"(*(g0,:,', '))") "sorted ", sorted
2041 : end if
2042 :
2043 : if (present(unique)) then
2044 : write(test%disp%unit,"(*(g0,:,', '))") "unique ", unique
2045 : end if
2046 :
2047 : if (present(keep)) then
2048 : write(test%disp%unit,"(*(g0,:,', '))") "keep ", keep
2049 : end if
2050 :
2051 : write(test%disp%unit,"(*(g0,:,', '))")
2052 : ! LCOV_EXCL_STOP
2053 :
2054 : end if
2055 :
2056 50232 : end subroutine
2057 :
2058 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2059 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2060 :
2061 : #undef GET_SIZE
2062 : #undef IS_EQUAL
2063 : #undef ALL
|
