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