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 : !> [getLoc](@ref pm_arrayFind::getLoc).
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 = "@setLoc/getLoc()"
34 :
35 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%
36 : #if loc_ENABLED && D1_D0_ENABLED
37 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%
38 :
39 : #if SK_ENABLED && D1_D0_ENABLED
40 : character(2,SKC), dimension(:), allocatable :: array
41 : character(2,SKC) :: pattern
42 : #elif IK_ENABLED && D1_D0_ENABLED
43 : integer(IKC) , dimension(:), allocatable :: array
44 : integer(IKC) :: pattern
45 : #elif LK_ENABLED && D1_D0_ENABLED
46 : logical(LKC) , dimension(:), allocatable :: array
47 : logical(LKC) :: pattern
48 : #elif CK_ENABLED && D1_D0_ENABLED
49 : complex(CKC) , dimension(:), allocatable :: array
50 : complex(CKC) :: pattern
51 : #elif RK_ENABLED && D1_D0_ENABLED
52 : real(RKC) , dimension(:), allocatable :: array
53 : real(RKC) :: pattern
54 : #else
55 : #error "Unrecognized interface."
56 : #endif
57 : integer(IK) , allocatable :: loc(:)
58 : integer(IK) , allocatable :: instance(:)
59 : integer(IK) , allocatable :: loc_ref(:)
60 : logical(LK) :: setLocEnabled
61 :
62 19 : assertion = .true._LK
63 :
64 19 : setLocEnabled = .false._LK
65 19 : call runTestsWith()
66 19 : call runTestsWith(iseq = iseq)
67 :
68 19 : setLocEnabled = .true._LK
69 19 : call runTestsWith()
70 19 : call runTestsWith(iseq = iseq)
71 :
72 : contains
73 :
74 19494 : function iseq(segment, pattern) result(equivalent)
75 : #if SK_ENABLED && D1_D0_ENABLED
76 : character(*,SKC), intent(in) :: segment, pattern
77 : #elif IK_ENABLED && D1_D0_ENABLED
78 : integer(IKC) , intent(in) :: segment, pattern
79 : #elif CK_ENABLED && D1_D0_ENABLED
80 : complex(CKC) , intent(in) :: segment, pattern
81 : #elif RK_ENABLED && D1_D0_ENABLED
82 : real(RKC) , intent(in) :: segment, pattern
83 : #elif LK_ENABLED && D1_D0_ENABLED
84 : logical(LKC) , intent(in) :: segment, pattern
85 : #endif
86 : logical(LK) :: equivalent
87 19494 : equivalent = pattern IS_EQUAL segment
88 19494 : end function
89 :
90 1292 : subroutine reset()
91 1292 : if (allocated(array)) deallocate(array)
92 1292 : if (allocated(instance)) deallocate(instance)
93 1292 : if (allocated(loc_ref)) deallocate(loc_ref)
94 1292 : end subroutine reset
95 :
96 76 : subroutine runTestsWith(iseq)
97 : logical(LK), external, optional :: iseq
98 :
99 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
100 :
101 76 : call reset()
102 :
103 : #if SK_ENABLED && D1_D0_ENABLED
104 4 : pattern = " "
105 : #elif IK_ENABLED && D1_D0_ENABLED
106 20 : pattern = 1_IKC
107 : #elif CK_ENABLED && D1_D0_ENABLED
108 16 : pattern = 1._CKC
109 : #elif RK_ENABLED && D1_D0_ENABLED
110 16 : pattern = 1._RKC
111 : #elif LK_ENABLED && D1_D0_ENABLED
112 20 : pattern = .false._LKC
113 : #endif
114 76 : loc_ref = [integer(IK) ::]
115 76 : allocate(instance(0))
116 76 : allocate(array(0))
117 :
118 76 : call report(__LINE__, iseq)
119 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
120 :
121 76 : call report(__LINE__, iseq, instance = instance)
122 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
123 :
124 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
125 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
126 :
127 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
128 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
129 :
130 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
131 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
132 :
133 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
134 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
135 :
136 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
137 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
138 :
139 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
140 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
141 :
142 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
143 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
144 :
145 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
146 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
147 :
148 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
149 :
150 76 : call report(__LINE__, iseq, blindness = 1_IK)
151 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
152 :
153 76 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
154 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
155 :
156 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
157 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `blindness = 1_IK, sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
158 :
159 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
160 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `blindness = 1_IK, sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
161 :
162 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
163 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `blindness = 1_IK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
164 :
165 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
166 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `blindness = 1_IK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
167 :
168 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
169 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `blindness = 1_IK, sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
170 :
171 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK, blindness = 1_IK)
172 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `blindness = 1_IK, sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
173 :
174 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
175 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `blindness = 1_IK, sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
176 :
177 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
178 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty array, has empty resulting loc with `instance` with `blindness = 1_IK, sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
179 :
180 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
181 :
182 76 : call reset()
183 :
184 : #if SK_ENABLED && D1_D0_ENABLED
185 16 : array = ["AA", "AA"]
186 4 : pattern = "AA"
187 : #elif IK_ENABLED && D1_D0_ENABLED
188 80 : array = [1_IKC, 1_IKC]
189 20 : pattern = 1_IKC
190 : #elif CK_ENABLED && D1_D0_ENABLED
191 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
192 16 : pattern = (1._CKC,-1._CKC)
193 : #elif RK_ENABLED && D1_D0_ENABLED
194 64 : array = [1._RKC, 1._RKC]
195 16 : pattern = 1._RKC
196 : #elif LK_ENABLED && D1_D0_ENABLED
197 80 : array = [.false._LK, .false._LK]
198 20 : pattern = .false._LK
199 : #endif
200 304 : instance = [1_IK, 2_IK]
201 304 : loc_ref= [1_IK, 2_IK]
202 :
203 76 : call report(__LINE__, iseq)
204 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
205 :
206 76 : call report(__LINE__, iseq, instance = instance)
207 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
208 :
209 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
210 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
211 :
212 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
213 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
214 :
215 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
216 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
217 :
218 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
219 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
220 :
221 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
222 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
223 :
224 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
225 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
226 :
227 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
228 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
229 :
230 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
231 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
232 :
233 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
234 :
235 76 : call report(__LINE__, iseq, blindness = 1_IK)
236 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
237 :
238 76 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
239 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
240 :
241 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
242 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
243 :
244 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
245 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
246 :
247 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
248 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `blindness = 1_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
249 :
250 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
251 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
252 :
253 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
254 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
255 :
256 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK, blindness = 1_IK)
257 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
258 :
259 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
260 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
261 :
262 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
263 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield an `loc` of elements of `array` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
264 :
265 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
266 :
267 76 : call reset()
268 :
269 : #if SK_ENABLED && D1_D0_ENABLED
270 16 : array = ["AA", "AA"]
271 4 : pattern = "BB"
272 : #elif IK_ENABLED && D1_D0_ENABLED
273 80 : array = [1_IKC, 1_IKC]
274 20 : pattern = 0_IKC
275 : #elif CK_ENABLED && D1_D0_ENABLED
276 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
277 16 : pattern = (0._CKC,-0._CKC)
278 : #elif RK_ENABLED && D1_D0_ENABLED
279 64 : array = [1._RKC, 1._RKC]
280 16 : pattern = 0._RKC
281 : #elif LK_ENABLED && D1_D0_ENABLED
282 80 : array = [.false._LK, .false._LK]
283 20 : pattern = .true._LK
284 : #endif
285 304 : instance = [1_IK, 2_IK]
286 76 : allocate(loc_ref(0))
287 :
288 76 : call report(__LINE__, iseq)
289 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
290 :
291 76 : call report(__LINE__, iseq, instance = instance)
292 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
293 :
294 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
295 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
296 :
297 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
298 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
299 :
300 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
301 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
302 :
303 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
304 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
305 :
306 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
307 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
308 :
309 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
310 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
311 :
312 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
313 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
314 :
315 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
316 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
317 :
318 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
319 :
320 76 : call report(__LINE__, iseq, blindness = 1_IK)
321 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` with `blindness = 1_IK` setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
322 :
323 76 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
324 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
325 :
326 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
327 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
328 :
329 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
330 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
331 :
332 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
333 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `blindness = 1_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
334 :
335 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
336 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
337 :
338 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
339 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
340 :
341 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK, blindness = 1_IK)
342 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
343 :
344 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
345 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
346 :
347 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
348 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are not the scalar `pattern` must yield an empty `loc` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
349 :
350 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
351 :
352 76 : call reset()
353 :
354 : #if SK_ENABLED && D1_D0_ENABLED
355 16 : array = ["AA", "AA"]
356 4 : pattern = "AA"
357 : #elif IK_ENABLED && D1_D0_ENABLED
358 80 : array = [1_IKC, 1_IKC]
359 20 : pattern = 1_IKC
360 : #elif CK_ENABLED && D1_D0_ENABLED
361 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
362 16 : pattern = (1._CKC,-1._CKC)
363 : #elif RK_ENABLED && D1_D0_ENABLED
364 64 : array = [1._RKC, 1._RKC]
365 16 : pattern = 1._RKC
366 : #elif LK_ENABLED && D1_D0_ENABLED
367 80 : array = [.false._LK, .false._LK]
368 20 : pattern = .false._LK
369 : #endif
370 304 : instance = [1_IK, 2_IK]
371 304 : loc_ref = [1_IK, 2_IK]
372 :
373 76 : call report(__LINE__, iseq)
374 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
375 :
376 76 : call report(__LINE__, iseq, instance = instance)
377 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
378 :
379 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
380 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
381 :
382 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
383 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
384 :
385 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
386 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
387 :
388 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
389 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
390 :
391 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
392 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
393 :
394 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
395 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
396 :
397 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
398 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
399 :
400 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
401 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
402 :
403 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
404 :
405 76 : call report(__LINE__, iseq, blindness = 1_IK)
406 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
407 :
408 76 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
409 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
410 :
411 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
412 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
413 :
414 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
415 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
416 :
417 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
418 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `blindness = 1_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
419 :
420 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
421 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
422 :
423 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
424 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `blindness = 1_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
425 :
426 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK, blindness = 1_IK)
427 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `blindness = 1_IK`, `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
428 :
429 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
430 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
431 :
432 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
433 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield the full index of `array` when `instance` is non-empty and out-of-bound with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
434 :
435 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
436 :
437 76 : call reset()
438 :
439 : #if SK_ENABLED && D1_D0_ENABLED
440 16 : array = ["AA", "AA"]
441 4 : pattern = "AA"
442 : #elif IK_ENABLED && D1_D0_ENABLED
443 80 : array = [1_IKC, 1_IKC]
444 20 : pattern = 1_IKC
445 : #elif CK_ENABLED && D1_D0_ENABLED
446 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
447 16 : pattern = (1._CKC,-1._CKC)
448 : #elif RK_ENABLED && D1_D0_ENABLED
449 64 : array = [1._RKC, 1._RKC]
450 16 : pattern = 1._RKC
451 : #elif LK_ENABLED && D1_D0_ENABLED
452 80 : array = [.false._LK, .false._LK]
453 20 : pattern = .false._LK
454 : #endif
455 304 : instance = [1_IK, 2_IK]
456 304 : loc_ref = [1_IK, 2_IK]
457 :
458 76 : call report(__LINE__, iseq)
459 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
460 :
461 76 : call report(__LINE__, iseq, instance = instance)
462 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
463 :
464 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
465 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
466 :
467 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
468 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
469 :
470 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
471 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
472 :
473 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
474 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
475 :
476 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
477 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
478 :
479 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
480 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
481 :
482 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
483 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
484 :
485 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
486 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
487 :
488 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
489 :
490 76 : call report(__LINE__, iseq, blindness = 1_IK)
491 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
492 :
493 76 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
494 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
495 :
496 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
497 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
498 :
499 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
500 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
501 :
502 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
503 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `blindness = 1_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
504 :
505 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
506 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
507 :
508 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
509 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `blindness = 1_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
510 :
511 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK, blindness = 1_IK)
512 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `blindness = 1_IK`, `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
513 :
514 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
515 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
516 :
517 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
518 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a full `loc` when `instance` is non-empty and mixed with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
519 :
520 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
521 :
522 76 : call reset()
523 :
524 : #if SK_ENABLED && D1_D0_ENABLED
525 16 : array = ["AA", "AA"]
526 4 : pattern = "AA"
527 : #elif IK_ENABLED && D1_D0_ENABLED
528 80 : array = [1_IKC, 1_IKC]
529 20 : pattern = 1_IKC
530 : #elif CK_ENABLED && D1_D0_ENABLED
531 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
532 16 : pattern = (1._CKC,-1._CKC)
533 : #elif RK_ENABLED && D1_D0_ENABLED
534 64 : array = [1._RKC, 1._RKC]
535 16 : pattern = 1._RKC
536 : #elif LK_ENABLED && D1_D0_ENABLED
537 80 : array = [.false._LK, .false._LK]
538 20 : pattern = .false._LK
539 : #endif
540 380 : instance = [1_IK, -2_IK, -1_IK]
541 380 : loc_ref = [1_IK, 1_IK, 2_IK]
542 :
543 76 : call report(__LINE__, iseq, instance = instance)
544 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
545 :
546 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
547 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
548 :
549 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
550 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
551 :
552 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
553 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
554 :
555 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
556 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
557 :
558 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
559 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
560 :
561 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
562 :
563 76 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
564 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
565 :
566 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
567 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
568 :
569 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
570 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
571 :
572 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
573 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
574 :
575 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
576 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
577 :
578 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
579 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
580 :
581 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
582 :
583 76 : call reset()
584 :
585 : #if SK_ENABLED && D1_D0_ENABLED
586 16 : array = ["AA", "AA"]
587 4 : pattern = "AA"
588 : #elif IK_ENABLED && D1_D0_ENABLED
589 80 : array = [1_IKC, 1_IKC]
590 20 : pattern = 1_IKC
591 : #elif CK_ENABLED && D1_D0_ENABLED
592 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
593 16 : pattern = (1._CKC,-1._CKC)
594 : #elif RK_ENABLED && D1_D0_ENABLED
595 64 : array = [1._RKC, 1._RKC]
596 16 : pattern = 1._RKC
597 : #elif LK_ENABLED && D1_D0_ENABLED
598 80 : array = [.false._LK, .false._LK]
599 20 : pattern = .false._LK
600 : #endif
601 456 : instance = [1_IK, -1_IK, -2_IK, 0_IK]
602 380 : loc_ref = [1_IK, 2_IK, 1_IK]
603 :
604 76 : call report(__LINE__, iseq, instance = instance)
605 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
606 :
607 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
608 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
609 :
610 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
611 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
612 :
613 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
614 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
615 :
616 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
617 :
618 76 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
619 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
620 :
621 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
622 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
623 :
624 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
625 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
626 :
627 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
628 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all scalar `pattern` must yield a redundant full `loc` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
629 :
630 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
631 :
632 76 : call reset()
633 :
634 : #if SK_ENABLED && D1_D0_ENABLED
635 20 : array = ["AA", "BB", "AA"]
636 4 : pattern = "AA"
637 : #elif IK_ENABLED && D1_D0_ENABLED
638 100 : array = [1_IKC, 2_IKC, 1_IKC]
639 20 : pattern = 1_IKC
640 : #elif CK_ENABLED && D1_D0_ENABLED
641 80 : array = [(1._CKC,-1._CKC), (2._CKC,-2._CKC), (1._CKC,-1._CKC)]
642 16 : pattern = (1._CKC,-1._CKC)
643 : #elif RK_ENABLED && D1_D0_ENABLED
644 80 : array = [1._RKC, 2._RKC, 1._RKC]
645 16 : pattern = 1._RKC
646 : #elif LK_ENABLED && D1_D0_ENABLED
647 100 : array = [.false._LK, .true._LK, .false._LK]
648 20 : pattern = .false._LK
649 : #endif
650 304 : instance = [1_IK, -2_IK]
651 304 : loc_ref = [1_IK, 1_IK]
652 :
653 76 : call report(__LINE__, iseq, instance = instance)
654 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
655 :
656 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
657 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
658 :
659 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
660 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
661 :
662 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
663 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
664 :
665 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
666 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
667 :
668 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
669 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
670 :
671 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
672 :
673 76 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
674 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
675 :
676 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
677 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
678 :
679 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
680 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
681 :
682 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
683 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
684 :
685 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
686 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
687 :
688 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
689 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc = [1,1]` when `instance = [1_IK, -2_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
690 :
691 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
692 :
693 76 : call reset()
694 :
695 : #if SK_ENABLED && D1_D0_ENABLED
696 20 : array = ["AA", "BB", "AA"]
697 4 : pattern = "AA"
698 : #elif IK_ENABLED && D1_D0_ENABLED
699 100 : array = [1_IKC, 2_IKC, 1_IKC]
700 20 : pattern = 1_IKC
701 : #elif CK_ENABLED && D1_D0_ENABLED
702 80 : array = [(1._CKC,-1._CKC), (2._CKC,-2._CKC), (1._CKC,-1._CKC)]
703 16 : pattern = (1._CKC,-1._CKC)
704 : #elif RK_ENABLED && D1_D0_ENABLED
705 80 : array = [1._RKC, 2._RKC, 1._RKC]
706 16 : pattern = 1._RKC
707 : #elif LK_ENABLED && D1_D0_ENABLED
708 100 : array = [.false._LK, .true._LK, .false._LK]
709 20 : pattern = .false._LK
710 : #endif
711 228 : instance = [-2_IK]
712 228 : loc_ref = [1_IK]
713 :
714 76 : call report(__LINE__, iseq, instance = instance)
715 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
716 :
717 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
718 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
719 :
720 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
721 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
722 :
723 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
724 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
725 :
726 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
727 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
728 :
729 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
730 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
731 :
732 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
733 :
734 76 : call report(__LINE__, iseq, instance = instance, blindness = 2_IK)
735 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive with `blindness = 2_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
736 :
737 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
738 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive, with `blindness = 2_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
739 :
740 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
741 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive, with `blindness = 2_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
742 :
743 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
744 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive, with `blindness = 2_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
745 :
746 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
747 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive, with `blindness = 2_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
748 :
749 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
750 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the beginning and the end matching the scalar `pattern` must yield an `loc_ref = [1_IK]` when `instance = [-2_IK]` is non-empty but incomprehensive and positive, with `blindness = 2_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
751 :
752 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
753 :
754 76 : call reset()
755 :
756 : #if SK_ENABLED && D1_D0_ENABLED
757 20 : array = ["BB", "AA", "AA"]
758 4 : pattern = "AA"
759 : #elif IK_ENABLED && D1_D0_ENABLED
760 100 : array = [2_IKC, 1_IKC, 1_IKC]
761 20 : pattern = 1_IKC
762 : #elif CK_ENABLED && D1_D0_ENABLED
763 80 : array = [(2._CKC,-2._CKC), (1._CKC,-1._CKC), (1._CKC,-1._CKC)]
764 16 : pattern = (1._CKC,-1._CKC)
765 : #elif RK_ENABLED && D1_D0_ENABLED
766 80 : array = [2._RKC, 1._RKC, 1._RKC]
767 16 : pattern = 1._RKC
768 : #elif LK_ENABLED && D1_D0_ENABLED
769 100 : array = [.true._LK, .false._LK, .false._LK]
770 20 : pattern = .false._LK
771 : #endif
772 304 : instance = [-1_IK, 3_IK]
773 228 : loc_ref = [3_IK]
774 :
775 76 : call report(__LINE__, iseq, instance = instance)
776 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
777 :
778 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
779 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
780 :
781 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
782 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
783 :
784 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
785 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
786 :
787 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
788 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
789 :
790 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
791 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
792 :
793 228 : instance = [2_IK]
794 :
795 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
796 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
797 :
798 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
799 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
800 :
801 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
802 :
803 228 : instance = [-1_IK]
804 :
805 228 : loc_ref = [2_IK]
806 76 : call report(__LINE__, iseq, instance = instance, blindness = 5_IK)
807 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed with `blindness = 5_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
808 :
809 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 5_IK)
810 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 5_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
811 :
812 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 5_IK)
813 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 5_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
814 :
815 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 5_IK)
816 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 5_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
817 :
818 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 5_IK)
819 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 5_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
820 :
821 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 5_IK)
822 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 5_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
823 :
824 228 : instance = [1_IK]
825 :
826 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 5_IK)
827 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 5_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
828 :
829 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 5_IK)
830 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 3 with the last two elements matching the scalar `pattern` must yield `loc = [3_IK]` when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 5_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
831 :
832 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
833 :
834 76 : call reset()
835 :
836 : #if SK_ENABLED && D1_D0_ENABLED
837 12 : array = ["AA"]
838 : #elif IK_ENABLED && D1_D0_ENABLED
839 60 : array = [1_IKC]
840 : #elif CK_ENABLED && D1_D0_ENABLED
841 48 : array = [(1._CKC,-1._CKC)]
842 : #elif RK_ENABLED && D1_D0_ENABLED
843 48 : array = [1._RKC]
844 : #elif LK_ENABLED && D1_D0_ENABLED
845 60 : array = [.false._LK]
846 : #endif
847 76 : pattern = array(1)
848 304 : instance = [-1_IK, 3_IK]
849 228 : loc_ref = [1_IK]
850 :
851 76 : call report(__LINE__, iseq, instance = instance)
852 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
853 :
854 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
855 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
856 :
857 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
858 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
859 :
860 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
861 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
862 :
863 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
864 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
865 :
866 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
867 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
868 :
869 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
870 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
871 :
872 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
873 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
874 :
875 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
876 :
877 76 : call report(__LINE__, iseq, instance = instance, blindness = 4_IK)
878 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed with `blindness = 4_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
879 :
880 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 4_IK)
881 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 4_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
882 :
883 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 4_IK)
884 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 4_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
885 :
886 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 4_IK)
887 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 4_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
888 :
889 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 4_IK)
890 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 4_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
891 :
892 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 4_IK)
893 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 4_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
894 :
895 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 4_IK)
896 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 4_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
897 :
898 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 4_IK)
899 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield loc = [1_IK] when `instance = [-1_IK, 3_IK]` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 4_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
900 :
901 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
902 :
903 76 : call reset()
904 :
905 : #if SK_ENABLED && D1_D0_ENABLED
906 12 : array = ["AA"]
907 : #elif IK_ENABLED && D1_D0_ENABLED
908 60 : array = [1_IKC]
909 : #elif CK_ENABLED && D1_D0_ENABLED
910 48 : array = [(1._CKC,-1._CKC)]
911 : #elif RK_ENABLED && D1_D0_ENABLED
912 48 : array = [1._RKC]
913 : #elif LK_ENABLED && D1_D0_ENABLED
914 60 : array = [.false._LK]
915 : #endif
916 76 : pattern = array(1)
917 304 : instance = [10_IK, 3_IK]
918 76 : loc_ref = [integer(IK)::]
919 :
920 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
921 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
922 :
923 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
924 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
925 :
926 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
927 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
928 :
929 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
930 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
931 :
932 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
933 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
934 :
935 304 : instance = [3_IK, 10_IK]
936 :
937 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
938 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
939 :
940 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
941 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
942 :
943 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
944 :
945 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 7_IK)
946 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 7_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
947 :
948 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 7_IK)
949 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 7_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
950 :
951 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 7_IK)
952 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 7_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
953 :
954 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 7_IK)
955 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 7_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
956 :
957 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 7_IK)
958 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 7_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
959 :
960 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 7_IK)
961 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 7_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
962 :
963 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 7_IK)
964 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 7_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
965 :
966 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
967 :
968 76 : call reset()
969 :
970 : #if SK_ENABLED && D1_D0_ENABLED
971 4 : allocate(character(2,SKC) :: array(0))
972 4 : pattern = "AA"
973 : #elif IK_ENABLED && D1_D0_ENABLED
974 20 : allocate(array(0))
975 20 : pattern = 1_IKC
976 : #elif CK_ENABLED && D1_D0_ENABLED
977 16 : allocate(array(0))
978 16 : pattern = (1._CKC,-1._CKC)
979 : #elif RK_ENABLED && D1_D0_ENABLED
980 16 : allocate(array(0))
981 16 : pattern = 1._RKC
982 : #elif LK_ENABLED && D1_D0_ENABLED
983 20 : allocate(array(0))
984 20 : pattern = .false._LK
985 : #endif
986 304 : instance = [10_IK, 3_IK]
987 76 : loc_ref = [integer(IK)::]
988 :
989 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
990 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
991 :
992 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
993 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
994 :
995 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
996 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
997 :
998 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
999 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1000 :
1001 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1002 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1003 :
1004 304 : instance = [3_IK, 10_IK]
1005 :
1006 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1007 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1008 :
1009 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
1010 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1011 :
1012 228 : instance = [1_IK]
1013 :
1014 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1015 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1016 :
1017 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1018 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1019 :
1020 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
1021 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1022 :
1023 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1024 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1025 :
1026 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1027 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1028 :
1029 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
1030 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1031 :
1032 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1033 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1034 :
1035 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1036 :
1037 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 10_IK)
1038 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1039 :
1040 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 10_IK)
1041 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1042 :
1043 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 10_IK)
1044 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1045 :
1046 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 10_IK)
1047 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1048 :
1049 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 10_IK)
1050 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1051 :
1052 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 10_IK)
1053 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1054 :
1055 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 10_IK)
1056 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1057 :
1058 228 : instance = [1_IK]
1059 :
1060 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 10_IK)
1061 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 10_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1062 :
1063 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 10_IK)
1064 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 10_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1065 :
1066 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 10_IK)
1067 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 10_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1068 :
1069 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 10_IK)
1070 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 10_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1071 :
1072 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 10_IK)
1073 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 10_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1074 :
1075 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 10_IK)
1076 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 10_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1077 :
1078 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 10_IK)
1079 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield an empty `loc` that is the same as the `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 10_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1080 :
1081 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1082 :
1083 76 : call reset()
1084 :
1085 : #if SK_ENABLED && D1_D0_ENABLED
1086 24 : array = ["AA", "BB", "CC", "AA"]
1087 4 : pattern = "AA"
1088 : #elif IK_ENABLED && D1_D0_ENABLED
1089 120 : array = [1_IKC, 2_IKC, 3_IKC, 1_IKC]
1090 20 : pattern = 1_IKC
1091 : #elif CK_ENABLED && D1_D0_ENABLED
1092 96 : array = [(1._CKC,-1._CKC), (2._CKC,-2._CKC), (3._CKC,-3._CKC), (1._CKC,-1._CKC)]
1093 16 : pattern = (1._CKC,-1._CKC)
1094 : #elif RK_ENABLED && D1_D0_ENABLED
1095 96 : array = [1._RKC, 2._RKC, 3._RKC, 1._RKC]
1096 16 : pattern = 1._RKC
1097 : #elif LK_ENABLED && D1_D0_ENABLED
1098 120 : array = [.false._LK, .true._LK, .true._LK, .false._LK]
1099 20 : pattern = .false._LK
1100 : #endif
1101 304 : instance = [1_IK, -1_IK]
1102 304 : loc_ref = [1_IK, 4_IK]
1103 :
1104 76 : call report(__LINE__, iseq)
1105 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 `loc = [1_IK, 4_IK]` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1106 :
1107 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1108 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1109 :
1110 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1111 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1112 :
1113 304 : instance = [1_IK, 2_IK]
1114 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
1115 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1116 :
1117 304 : instance = [1_IK, -1_IK]
1118 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1119 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1120 :
1121 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1122 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1123 :
1124 304 : instance = [1_IK, 2_IK]
1125 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
1126 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1127 :
1128 304 : instance = [1_IK, -1_IK]
1129 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1130 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1131 :
1132 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1133 :
1134 76 : call report(__LINE__, iseq, blindness = 3_IK)
1135 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 `loc = [1_IK, 4_IK]` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1136 :
1137 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 3_IK)
1138 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 3_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1139 :
1140 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 3_IK)
1141 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 3_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1142 :
1143 304 : instance = [1_IK, 2_IK]
1144 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 3_IK)
1145 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 3_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1146 :
1147 304 : instance = [1_IK, -1_IK]
1148 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 3_IK)
1149 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 3_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1150 :
1151 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 3_IK)
1152 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 3_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1153 :
1154 304 : instance = [1_IK, 2_IK]
1155 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 3_IK)
1156 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 3_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1157 :
1158 304 : instance = [1_IK, -1_IK]
1159 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 3_IK)
1160 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 `loc = [1_IK, 4_IK]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 3_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1161 :
1162 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1163 :
1164 76 : call reset()
1165 :
1166 : #if SK_ENABLED && D1_D0_ENABLED
1167 16 : array = ["AA", "AA"]
1168 4 : pattern = "XX"
1169 : #elif IK_ENABLED && D1_D0_ENABLED
1170 80 : array = [1_IKC, 1_IKC]
1171 20 : pattern = 0_IKC
1172 : #elif CK_ENABLED && D1_D0_ENABLED
1173 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1174 16 : pattern = (0._CKC,0._CKC)
1175 : #elif RK_ENABLED && D1_D0_ENABLED
1176 64 : array = [1._RKC, 1._RKC]
1177 16 : pattern = 0._RKC
1178 : #elif LK_ENABLED && D1_D0_ENABLED
1179 80 : array = [.false._LK, .false._LK]
1180 20 : pattern = .true._LK
1181 : #endif
1182 304 : instance = [10_IK, 3_IK]
1183 76 : loc_ref = [integer(IK)::]
1184 :
1185 76 : call report(__LINE__, iseq)
1186 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1187 :
1188 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1189 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1190 :
1191 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1192 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1193 :
1194 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
1195 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1196 :
1197 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1198 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1199 :
1200 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1201 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1202 :
1203 304 : instance = [3_IK, 10_IK]
1204 :
1205 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1206 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1207 :
1208 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
1209 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1210 :
1211 228 : instance = [1_IK]
1212 :
1213 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1214 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1215 :
1216 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1217 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1218 :
1219 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
1220 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1221 :
1222 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1223 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1224 :
1225 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1226 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1227 :
1228 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
1229 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1230 :
1231 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1232 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1233 :
1234 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1235 :
1236 76 : call report(__LINE__, iseq, blindness = 1_IK)
1237 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1238 :
1239 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
1240 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1241 :
1242 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
1243 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1244 :
1245 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
1246 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1247 :
1248 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
1249 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1250 :
1251 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
1252 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1253 :
1254 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
1255 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1256 :
1257 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
1258 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1259 :
1260 228 : instance = [1_IK]
1261 :
1262 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
1263 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1264 :
1265 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
1266 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1267 :
1268 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
1269 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 1_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1270 :
1271 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
1272 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1273 :
1274 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
1275 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1276 :
1277 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
1278 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 1_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1279 :
1280 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
1281 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield an empty `loc` of size one whose value is `array` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1282 :
1283 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1284 :
1285 76 : call reset()
1286 :
1287 : #if SK_ENABLED && D1_D0_ENABLED
1288 28 : array = ["AA", "XX", "AA", "XX", "AA"]
1289 4 : pattern = "XX"
1290 : #elif IK_ENABLED && D1_D0_ENABLED
1291 140 : array = [1_IKC, 0_IKC, 1_IKC, 0_IKC, 1_IKC]
1292 20 : pattern = 0_IKC
1293 : #elif CK_ENABLED && D1_D0_ENABLED
1294 112 : array = [(1._CKC,-1._CKC), (0._CKC,0._CKC), (1._CKC,-1._CKC), (0._CKC,0._CKC), (1._CKC,-1._CKC)]
1295 16 : pattern = (0._CKC,0._CKC)
1296 : #elif RK_ENABLED && D1_D0_ENABLED
1297 112 : array = [1._RKC, 0._RKC, 1._RKC, 0._RKC, 1._RKC]
1298 16 : pattern = 0._RKC
1299 : #elif LK_ENABLED && D1_D0_ENABLED
1300 140 : array = [.false._LK, .true._LK, .false._LK, .true._LK, .false._LK]
1301 20 : pattern = .true._LK
1302 : #endif
1303 304 : instance = [1_IK, -1_IK]
1304 304 : loc_ref = [2_IK, 4_IK]
1305 :
1306 76 : call report(__LINE__, iseq)
1307 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1308 :
1309 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1310 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1311 :
1312 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1313 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1314 :
1315 304 : instance = [1_IK, 2_IK]
1316 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
1317 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1318 :
1319 304 : instance = [1_IK, -1_IK]
1320 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1321 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1322 :
1323 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1324 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1325 :
1326 304 : instance = [1_IK, 2_IK]
1327 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
1328 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1329 :
1330 304 : instance = [1_IK, -1_IK]
1331 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1332 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1333 :
1334 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1335 :
1336 76 : call report(__LINE__, iseq, blindness = 2_IK)
1337 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` with `blindness = 2_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1338 :
1339 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
1340 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `blindness = 2_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1341 :
1342 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
1343 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `blindness = 2_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1344 :
1345 304 : instance = [1_IK, 2_IK]
1346 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 2_IK)
1347 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `blindness = 2_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1348 :
1349 304 : instance = [1_IK, -1_IK]
1350 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
1351 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `blindness = 2_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1352 :
1353 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
1354 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `blindness = 2_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1355 :
1356 304 : instance = [1_IK, 2_IK]
1357 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 2_IK)
1358 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `blindness = 2_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1359 :
1360 304 : instance = [1_IK, -1_IK]
1361 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
1362 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc = [1_IK, 5_IK]` when `instance` is ordered, positive, non-empty but sensible, with `blindness = 2_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1363 :
1364 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1365 :
1366 76 : call reset()
1367 :
1368 : #if SK_ENABLED && D1_D0_ENABLED
1369 16 : array = ["AA", "AA"]
1370 4 : pattern = "AA"
1371 : #elif IK_ENABLED && D1_D0_ENABLED
1372 80 : array = [1_IKC, 1_IKC]
1373 20 : pattern = 1_IKC
1374 : #elif CK_ENABLED && D1_D0_ENABLED
1375 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1376 16 : pattern = (1._CKC,-1._CKC)
1377 : #elif RK_ENABLED && D1_D0_ENABLED
1378 64 : array = [1._RKC, 1._RKC]
1379 16 : pattern = 1._RKC
1380 : #elif LK_ENABLED && D1_D0_ENABLED
1381 80 : array = [.false._LK, .false._LK]
1382 20 : pattern = .false._LK
1383 : #endif
1384 304 : instance = [10_IK, 3_IK]
1385 76 : loc_ref = [integer(IK)::]
1386 :
1387 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1388 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1389 :
1390 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1391 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1392 :
1393 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
1394 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1395 :
1396 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1397 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1398 :
1399 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1400 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1401 :
1402 304 : instance = [3_IK, 10_IK]
1403 :
1404 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1405 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1406 :
1407 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
1408 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1409 :
1410 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1411 :
1412 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
1413 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1414 :
1415 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
1416 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1417 :
1418 76 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 2_IK)
1419 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1420 :
1421 76 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
1422 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1423 :
1424 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
1425 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1426 :
1427 76 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 2_IK)
1428 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1429 :
1430 76 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
1431 76 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield an empty `loc` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1432 :
1433 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1434 :
1435 76 : end subroutine
1436 :
1437 : subroutine report ( line & ! LCOV_EXCL_LINE
1438 : , iseq & ! LCOV_EXCL_LINE
1439 : , instance & ! LCOV_EXCL_LINE
1440 : , blindness & ! LCOV_EXCL_LINE
1441 : , positive & ! LCOV_EXCL_LINE
1442 : , sorted & ! LCOV_EXCL_LINE
1443 : )
1444 : integer, intent(in) :: line
1445 : logical(LK) , external , optional :: iseq
1446 : integer(IK) , intent(in), optional, contiguous :: instance(:)
1447 : integer(IK) , intent(in), optional :: blindness
1448 : logical(LK) , intent(in), optional :: positive
1449 : logical(LK) , intent(in), optional :: sorted
1450 : logical(LK) :: sorted_def, positive_def
1451 : integer(IK) :: blindness_def, nloc
1452 :
1453 22344 : sorted_def = .false._LK; if (present(sorted)) sorted_def = sorted
1454 22344 : positive_def = .false._LK; if (present(positive)) positive_def = positive
1455 22344 : blindness_def = 1_IK; if (present(blindness)) blindness_def = blindness
1456 :
1457 22344 : if (setLocEnabled) then
1458 11172 : if (present(iseq) .and. present(instance)) then
1459 5282 : call setLoc(loc, nloc, array, pattern, iseq, instance, sorted_def, positive_def, blindness_def)
1460 5890 : elseif (present(instance)) then
1461 5282 : call setLoc(loc, nloc, array, pattern, instance, sorted_def, positive_def, blindness_def)
1462 608 : elseif (present(iseq)) then
1463 304 : call setLoc(loc, nloc, array, pattern, iseq, blindness_def)
1464 : else
1465 304 : call setLoc(loc, nloc, array, pattern, blindness_def)
1466 : end if
1467 : else
1468 11172 : if (present(iseq) .and. present(instance) .and. present(sorted) .and. present(positive)) then
1469 6498 : loc = getLoc(array, pattern, iseq = iseq, instance = instance, sorted = sorted, positive = positive, blindness = blindness)
1470 9006 : elseif (present(iseq) .and. present(instance) .and. present(sorted) .and. .not. present(positive)) then
1471 4294 : loc = getLoc(array, pattern, iseq = iseq, instance = instance, sorted = sorted, blindness = blindness)
1472 7600 : elseif (present(iseq) .and. present(instance) .and. .not. present(sorted) .and. present(positive)) then
1473 3838 : loc = getLoc(array, pattern, iseq = iseq, instance = instance, positive = positive, blindness = blindness)
1474 6308 : elseif (present(iseq) .and. present(instance) .and. .not. present(sorted) .and. .not. present(positive)) then
1475 1482 : loc = getLoc(array, pattern, iseq = iseq, instance = instance, blindness = blindness)
1476 5890 : elseif (present(iseq) .and. .not. present(instance) .and. .not. present(sorted) .and. .not. present(positive)) then
1477 988 : loc = getLoc(array, pattern, iseq = iseq, blindness = blindness)
1478 5586 : elseif (.not. present(iseq) .and. present(instance) .and. present(sorted) .and. present(positive)) then
1479 6498 : loc = getLoc(array, pattern, instance = instance, sorted = sorted, positive = positive, blindness = blindness)
1480 3420 : elseif (.not. present(iseq) .and. present(instance) .and. present(sorted) .and. .not. present(positive)) then
1481 4294 : loc = getLoc(array, pattern, instance = instance, sorted = sorted, blindness = blindness)
1482 2014 : elseif (.not. present(iseq) .and. present(instance) .and. .not. present(sorted) .and. present(positive)) then
1483 3838 : loc = getLoc(array, pattern, instance = instance, positive = positive, blindness = blindness)
1484 722 : elseif (.not. present(iseq) .and. present(instance) .and. .not. present(sorted) .and. .not. present(positive)) then
1485 1482 : loc = getLoc(array, pattern, instance = instance, blindness = blindness)
1486 304 : elseif (.not. present(iseq) .and. .not. present(instance) .and. .not. present(sorted) .and. .not. present(positive)) then
1487 988 : loc = getLoc(array, pattern, blindness = blindness)
1488 : else
1489 : error stop PROCEDURE_NAME//SK_": Unrecognized interface in testing." ! LCOV_EXCL_LINE
1490 : end if
1491 11172 : nloc = size(loc, 1, IK)
1492 : end if
1493 :
1494 : ! Report test results if needed.
1495 :
1496 : !write(*,*) setLocEnabled, present(instance), present(sorted), present(positive)
1497 : !write(*,*) array
1498 : !write(*,*) pattern
1499 : !write(*,*) loc
1500 : !write(*,*) loc_ref
1501 :
1502 22344 : assertion = assertion .and. nloc == size(loc_ref, 1, IK)
1503 46056 : if (assertion .and. 0_IK < nloc) assertion = assertion .and. all(loc(1 : nloc) == loc_ref)
1504 :
1505 22344 : if (test%traceable .and. .not. assertion) then
1506 : ! LCOV_EXCL_START
1507 : call test%disp%skip()
1508 : call test%disp%show("array")
1509 : call test%disp%show( array )
1510 : call test%disp%show("pattern")
1511 : call test%disp%show( pattern )
1512 : call test%disp%show("nloc")
1513 : call test%disp%show( nloc )
1514 : call test%disp%show("loc_ref")
1515 : call test%disp%show( loc_ref )
1516 : call test%disp%show("loc(1:nloc)")
1517 : call test%disp%show( loc(1:nloc) )
1518 : call test%disp%show("present(iseq)")
1519 : call test%disp%show( present(iseq) )
1520 : call test%disp%show("present(instance)")
1521 : call test%disp%show( present(instance) )
1522 : if (present(instance)) then
1523 : call test%disp%show("instance")
1524 : call test%disp%show( instance )
1525 : end if
1526 : call test%disp%show("present(positive)")
1527 : call test%disp%show( present(positive) )
1528 : if (present(positive)) then
1529 : call test%disp%show("positive")
1530 : call test%disp%show( positive )
1531 : end if
1532 : call test%disp%show("present(sorted)")
1533 : call test%disp%show( present(sorted) )
1534 : if (present(sorted)) then
1535 : call test%disp%show("sorted")
1536 : call test%disp%show( sorted )
1537 : end if
1538 : call test%disp%show("present(blindness)")
1539 : call test%disp%show( present(blindness) )
1540 : if (present(blindness)) then
1541 : call test%disp%show("blindness")
1542 : call test%disp%show( blindness )
1543 : end if
1544 : call test%disp%skip()
1545 : ! LCOV_EXCL_STOP
1546 : end if
1547 :
1548 22344 : if (nloc /= size(loc_ref, 1, IK)) call test%assert(assertion, PROCEDURE_NAME//SK_": The condition `nloc = size(loc_ref) must hold.", int(line, IK))
1549 :
1550 22344 : end subroutine
1551 :
1552 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1553 : #elif loc_ENABLED && (D0_D0_ENABLED || D1_D1_ENABLED)
1554 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1555 :
1556 : #if SK_ENABLED && D0_D0_ENABLED
1557 : #define ALL
1558 1 : character(:,SKC), allocatable :: array, pattern
1559 : #elif SK_ENABLED && D1_D1_ENABLED
1560 : character(2,SKC), dimension(:), allocatable :: array, pattern
1561 : #elif IK_ENABLED && D1_D1_ENABLED
1562 : integer(IKC) , dimension(:), allocatable :: array, pattern
1563 : #elif LK_ENABLED && D1_D1_ENABLED
1564 : logical(LKC) , dimension(:), allocatable :: array, pattern
1565 : #elif CK_ENABLED && D1_D1_ENABLED
1566 : complex(CKC) , dimension(:), allocatable :: array, pattern
1567 : #elif RK_ENABLED && D1_D1_ENABLED
1568 : real(RKC) , dimension(:), allocatable :: array, pattern
1569 : #else
1570 : #error "Unrecognized interface."
1571 : #endif
1572 : integer(IK) , allocatable :: loc(:)
1573 : integer(IK) , allocatable :: instance(:)
1574 : integer(IK) , allocatable :: loc_ref(:)
1575 : logical(LK) :: setLocEnabled
1576 :
1577 20 : assertion = .true._LK
1578 :
1579 20 : setLocEnabled = .false._LK
1580 20 : call runTestsWith()
1581 20 : call runTestsWith(iseq = iseq)
1582 :
1583 20 : setLocEnabled = .true._LK
1584 20 : call runTestsWith()
1585 20 : call runTestsWith(iseq = iseq)
1586 :
1587 : contains
1588 :
1589 : function iseq(Segment, pattern & ! LCOV_EXCL_LINE
1590 : #if D1_D1_ENABLED
1591 : , lenPattern & ! LCOV_EXCL_LINE
1592 : #endif
1593 : ) result(equivalent)
1594 : #if D1_D1_ENABLED
1595 : integer(IK) , intent(in) :: lenPattern
1596 : #endif
1597 : #if SK_ENABLED && D0_D0_ENABLED
1598 : character(*, SK), intent(in) :: segment, pattern
1599 : #elif SK_ENABLED && D1_D1_ENABLED
1600 : character(*, SK), intent(in) :: Segment(lenPattern), pattern(lenPattern)
1601 : #elif IK_ENABLED && D1_D1_ENABLED
1602 : integer(IKC) , intent(in) :: Segment(lenPattern), pattern(lenPattern)
1603 : #elif CK_ENABLED && D1_D1_ENABLED
1604 : complex(CKC) , intent(in) :: Segment(lenPattern), pattern(lenPattern)
1605 : #elif RK_ENABLED && D1_D1_ENABLED
1606 : real(RKC) , intent(in) :: Segment(lenPattern), pattern(lenPattern)
1607 : #elif LK_ENABLED && D1_D1_ENABLED
1608 : logical(LKC) , intent(in) :: Segment(lenPattern), pattern(lenPattern)
1609 : #endif
1610 : logical(LK) :: equivalent
1611 46470 : equivalent = ALL(pattern IS_EQUAL Segment)
1612 23860 : end function
1613 :
1614 1760 : subroutine reset()
1615 1760 : if (allocated(array)) deallocate(array)
1616 1760 : if (allocated(pattern)) deallocate(pattern)
1617 1760 : if (allocated(instance)) deallocate(instance)
1618 1760 : if (allocated(loc_ref)) deallocate(loc_ref)
1619 1760 : end subroutine reset
1620 :
1621 80 : subroutine runTestsWith(iseq)
1622 : logical(LK), external, optional :: iseq
1623 :
1624 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1625 :
1626 80 : call reset()
1627 :
1628 : #if SK_ENABLED && D0_D0_ENABLED
1629 4 : pattern = " "
1630 4 : allocate(character(0,SKC) :: array)
1631 : #elif SK_ENABLED && D1_D1_ENABLED
1632 12 : pattern = [" "]
1633 4 : allocate(character(2,SKC) :: array(0))
1634 : #elif IK_ENABLED && D1_D1_ENABLED
1635 60 : pattern = [1_IKC]
1636 20 : allocate(array(0))
1637 : #elif CK_ENABLED && D1_D1_ENABLED
1638 48 : pattern = [1._CKC]
1639 16 : allocate(array(0))
1640 : #elif RK_ENABLED && D1_D1_ENABLED
1641 48 : pattern = [1._RKC]
1642 16 : allocate(array(0))
1643 : #elif LK_ENABLED && D1_D1_ENABLED
1644 60 : pattern = [.false._LK]
1645 20 : allocate(array(0))
1646 : #endif
1647 80 : allocate(instance(0))
1648 80 : allocate(loc_ref(0))
1649 :
1650 80 : call report(__LINE__, iseq)
1651 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1652 :
1653 80 : call report(__LINE__, iseq, instance = instance)
1654 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1655 :
1656 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1657 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1658 :
1659 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1660 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1661 :
1662 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
1663 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1664 :
1665 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1666 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1667 :
1668 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
1669 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1670 :
1671 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
1672 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1673 :
1674 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1675 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1676 :
1677 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1678 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1679 :
1680 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1681 :
1682 80 : call report(__LINE__, iseq, blindness = 20_IK)
1683 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `blindness = 20_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1684 :
1685 80 : call report(__LINE__, iseq, instance = instance, blindness = 20_IK)
1686 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `blindness = 20_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1687 :
1688 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 20_IK)
1689 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `blindness = 20_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1690 :
1691 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 20_IK)
1692 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `blindness = 20_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1693 :
1694 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 20_IK)
1695 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `blindness = 20_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1696 :
1697 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 20_IK)
1698 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `blindness = 20_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1699 :
1700 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 20_IK)
1701 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `blindness = 20_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1702 :
1703 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK, blindness = 20_IK)
1704 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `blindness = 20_IK`, `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1705 :
1706 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 20_IK)
1707 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `blindness = 20_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1708 :
1709 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 20_IK)
1710 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An empty `array` has empty resulting `loc` with `instance` with `blindness = 20_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1711 :
1712 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1713 :
1714 80 : call reset()
1715 :
1716 : #if SK_ENABLED && D0_D0_ENABLED
1717 4 : array = "AAA"
1718 4 : pattern = "AA"
1719 : #elif SK_ENABLED && D1_D1_ENABLED
1720 16 : array = ["AA", "AA"]
1721 12 : pattern = ["AA"]
1722 : #elif IK_ENABLED && D1_D1_ENABLED
1723 80 : array = [1_IKC, 1_IKC]
1724 60 : pattern = [1_IKC]
1725 : #elif CK_ENABLED && D1_D1_ENABLED
1726 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1727 48 : pattern = [(1._CKC,-1._CKC)]
1728 : #elif RK_ENABLED && D1_D1_ENABLED
1729 64 : array = [1._RKC, 1._RKC]
1730 48 : pattern = [1._RKC]
1731 : #elif LK_ENABLED && D1_D1_ENABLED
1732 80 : array = [.false._LK, .false._LK]
1733 60 : pattern = [.false._LK]
1734 : #endif
1735 320 : instance = [1_IK, 2_IK]
1736 320 : loc_ref = [1_IK, 2_IK]
1737 :
1738 80 : call report(__LINE__, iseq)
1739 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1740 :
1741 80 : call report(__LINE__, iseq, instance = instance)
1742 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1743 :
1744 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1745 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1746 :
1747 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1748 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1749 :
1750 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
1751 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1752 :
1753 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1754 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1755 :
1756 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
1757 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1758 :
1759 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
1760 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1761 :
1762 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1763 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1764 :
1765 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1766 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1767 :
1768 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1769 :
1770 80 : call report(__LINE__, iseq, blindness = 1_IK)
1771 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1772 :
1773 80 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
1774 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1775 :
1776 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
1777 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1778 :
1779 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
1780 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1781 :
1782 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
1783 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `blindness = 1_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1784 :
1785 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
1786 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1787 :
1788 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
1789 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1790 :
1791 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK, blindness = 1_IK)
1792 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1793 :
1794 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
1795 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1796 :
1797 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
1798 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1799 :
1800 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1801 :
1802 80 : call reset()
1803 :
1804 : #if SK_ENABLED && D0_D0_ENABLED
1805 4 : array = "AAA"
1806 4 : pattern = "AA"
1807 : #elif SK_ENABLED && D1_D1_ENABLED
1808 16 : array = ["AA", "AA"]
1809 12 : pattern = ["AA"]
1810 : #elif IK_ENABLED && D1_D1_ENABLED
1811 80 : array = [1_IKC, 1_IKC]
1812 60 : pattern = [1_IKC]
1813 : #elif CK_ENABLED && D1_D1_ENABLED
1814 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1815 48 : pattern = [(1._CKC,-1._CKC)]
1816 : #elif RK_ENABLED && D1_D1_ENABLED
1817 64 : array = [1._RKC, 1._RKC]
1818 48 : pattern = [1._RKC]
1819 : #elif LK_ENABLED && D1_D1_ENABLED
1820 80 : array = [.false._LK, .false._LK]
1821 60 : pattern = [.false._LK]
1822 : #endif
1823 400 : instance = [1_IK, 2_IK, 3_IK]
1824 320 : loc_ref = [1_IK, 2_IK]
1825 :
1826 80 : call report(__LINE__, iseq)
1827 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1828 :
1829 80 : call report(__LINE__, iseq, instance = instance)
1830 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1831 :
1832 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1833 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1834 :
1835 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1836 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1837 :
1838 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
1839 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1840 :
1841 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1842 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1843 :
1844 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
1845 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1846 :
1847 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
1848 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1849 :
1850 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1851 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1852 :
1853 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1854 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1855 :
1856 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1857 :
1858 80 : call report(__LINE__, iseq, blindness = 1_IK)
1859 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1860 :
1861 80 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
1862 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1863 :
1864 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
1865 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1866 :
1867 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
1868 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1869 :
1870 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
1871 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `blindness = 1_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1872 :
1873 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
1874 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1875 :
1876 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
1877 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `blindness = 1_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1878 :
1879 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK, blindness = 1_IK)
1880 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1881 :
1882 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
1883 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1884 :
1885 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
1886 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty and redundant with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1887 :
1888 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1889 :
1890 80 : call reset()
1891 :
1892 : #if SK_ENABLED && D0_D0_ENABLED
1893 4 : array = "AAA"
1894 4 : pattern = "AA"
1895 : #elif SK_ENABLED && D1_D1_ENABLED
1896 16 : array = ["AA", "AA"]
1897 12 : pattern = ["AA"]
1898 : #elif IK_ENABLED && D1_D1_ENABLED
1899 80 : array = [1_IKC, 1_IKC]
1900 60 : pattern = [1_IKC]
1901 : #elif CK_ENABLED && D1_D1_ENABLED
1902 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1903 48 : pattern = [(1._CKC,-1._CKC)]
1904 : #elif RK_ENABLED && D1_D1_ENABLED
1905 64 : array = [1._RKC, 1._RKC]
1906 48 : pattern = [1._RKC]
1907 : #elif LK_ENABLED && D1_D1_ENABLED
1908 80 : array = [.false._LK, .false._LK]
1909 60 : pattern = [.false._LK]
1910 : #endif
1911 320 : instance = [1_IK, -1_IK]
1912 320 : loc_ref = [1_IK, 2_IK]
1913 :
1914 80 : call report(__LINE__, iseq)
1915 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1916 :
1917 80 : call report(__LINE__, iseq, instance = instance)
1918 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1919 :
1920 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1921 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1922 :
1923 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1924 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1925 :
1926 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1927 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1928 :
1929 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1930 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1931 :
1932 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
1933 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1934 :
1935 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1936 :
1937 80 : call report(__LINE__, iseq, blindness = 1_IK)
1938 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1939 :
1940 80 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
1941 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1942 :
1943 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
1944 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1945 :
1946 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
1947 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1948 :
1949 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
1950 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1951 :
1952 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
1953 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1954 :
1955 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
1956 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield loc = [1_IK, 2_IK] when `instance` is non-empty and mixed with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1957 :
1958 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1959 :
1960 80 : call reset()
1961 :
1962 : #if SK_ENABLED && D0_D0_ENABLED
1963 4 : array = "AAA"
1964 4 : pattern = "AA"
1965 : #elif SK_ENABLED && D1_D1_ENABLED
1966 16 : array = ["AA", "AA"]
1967 12 : pattern = ["AA"]
1968 : #elif IK_ENABLED && D1_D1_ENABLED
1969 80 : array = [1_IKC, 1_IKC]
1970 60 : pattern = [1_IKC]
1971 : #elif CK_ENABLED && D1_D1_ENABLED
1972 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
1973 48 : pattern = [(1._CKC,-1._CKC)]
1974 : #elif RK_ENABLED && D1_D1_ENABLED
1975 64 : array = [1._RKC, 1._RKC]
1976 48 : pattern = [1._RKC]
1977 : #elif LK_ENABLED && D1_D1_ENABLED
1978 80 : array = [.false._LK, .false._LK]
1979 60 : pattern = [.false._LK]
1980 : #endif
1981 400 : instance = [1_IK, -2_IK, -1_IK]
1982 400 : loc_ref = [1_IK, 1_IK, 2_IK]
1983 :
1984 80 : call report(__LINE__, iseq, instance = instance)
1985 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1986 :
1987 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
1988 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1989 :
1990 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
1991 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1992 :
1993 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
1994 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1995 :
1996 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
1997 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
1998 :
1999 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2000 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2001 :
2002 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2003 :
2004 80 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
2005 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2006 :
2007 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
2008 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2009 :
2010 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
2011 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2012 :
2013 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
2014 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2015 :
2016 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
2017 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2018 :
2019 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
2020 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the single-element vector `pattern` must yield `loc = [1_IK, 1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2021 :
2022 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2023 :
2024 80 : call reset()
2025 :
2026 : #if SK_ENABLED && D0_D0_ENABLED
2027 4 : array = "AAA"
2028 4 : pattern = "AA"
2029 : #elif SK_ENABLED && D1_D1_ENABLED
2030 20 : array = ["AA", "AA", "AA"]
2031 16 : pattern = ["AA", "AA"]
2032 : #elif IK_ENABLED && D1_D1_ENABLED
2033 100 : array = [1_IKC, 1_IKC, 1_IKC]
2034 80 : pattern = [1_IKC, 1_IKC]
2035 : #elif CK_ENABLED && D1_D1_ENABLED
2036 80 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2037 64 : pattern = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2038 : #elif RK_ENABLED && D1_D1_ENABLED
2039 80 : array = [1._RKC, 1._RKC, 1._RKC]
2040 64 : pattern = [1._RKC, 1._RKC]
2041 : #elif LK_ENABLED && D1_D1_ENABLED
2042 100 : array = [.false._LK, .false._LK, .false._LK]
2043 80 : pattern = [.false._LK, .false._LK]
2044 : #endif
2045 320 : instance = [1_IK, 2_IK]
2046 320 : loc_ref = [1_IK, 2_IK]
2047 :
2048 80 : call report(__LINE__, iseq)
2049 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2050 :
2051 80 : call report(__LINE__, iseq, instance = instance)
2052 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2053 :
2054 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2055 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2056 :
2057 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2058 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2059 :
2060 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2061 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2062 :
2063 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2064 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2065 :
2066 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2067 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2068 :
2069 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2070 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2071 :
2072 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2073 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2074 :
2075 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
2076 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2077 :
2078 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2079 :
2080 80 : call report(__LINE__, iseq, blindness = 1_IK)
2081 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2082 :
2083 80 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
2084 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2085 :
2086 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
2087 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2088 :
2089 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
2090 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2091 :
2092 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
2093 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2094 :
2095 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
2096 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2097 :
2098 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
2099 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2100 :
2101 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
2102 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2103 :
2104 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
2105 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2106 :
2107 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK, blindness = 1_IK)
2108 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK]` when `instance` is non-empty, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .false._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2109 :
2110 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2111 :
2112 80 : call reset()
2113 :
2114 : #if SK_ENABLED && D0_D0_ENABLED
2115 4 : array = "AAA"
2116 4 : pattern = "AA"
2117 : #elif SK_ENABLED && D1_D1_ENABLED
2118 20 : array = ["AA", "AA", "AA"]
2119 16 : pattern = ["AA", "AA"]
2120 : #elif IK_ENABLED && D1_D1_ENABLED
2121 100 : array = [1_IKC, 1_IKC, 1_IKC]
2122 80 : pattern = [1_IKC, 1_IKC]
2123 : #elif CK_ENABLED && D1_D1_ENABLED
2124 80 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2125 64 : pattern = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2126 : #elif RK_ENABLED && D1_D1_ENABLED
2127 80 : array = [1._RKC, 1._RKC, 1._RKC]
2128 64 : pattern = [1._RKC, 1._RKC]
2129 : #elif LK_ENABLED && D1_D1_ENABLED
2130 100 : array = [.false._LK, .false._LK, .false._LK]
2131 80 : pattern = [.false._LK, .false._LK]
2132 : #endif
2133 480 : instance = [1_IK, -1_IK, -2_IK, 0_IK]
2134 400 : loc_ref = [1_IK, 2_IK, 1_IK]
2135 :
2136 80 : call report(__LINE__, iseq, instance = instance)
2137 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK, 1_IK]` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2138 :
2139 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2140 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK, 1_IK]` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2141 :
2142 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2143 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK, 1_IK]` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2144 :
2145 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2146 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK, 1_IK]` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2147 :
2148 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2149 :
2150 80 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
2151 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK, 1_IK]` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2152 :
2153 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
2154 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK, 1_IK]` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2155 :
2156 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
2157 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK, 1_IK]` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2158 :
2159 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
2160 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` whose elements are all the double-element vector `pattern` must yield `loc = [1_IK, 2_IK, 1_IK]` when `instance` is non-empty, redundant, non-positive, unsorted, and mixed, with `blindness = 1_IK`, `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2161 :
2162 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2163 :
2164 80 : call reset()
2165 :
2166 : #if SK_ENABLED && D0_D0_ENABLED
2167 4 : array = "AABBAA"
2168 4 : pattern = "AA"
2169 : #elif SK_ENABLED && D1_D1_ENABLED
2170 32 : array = ["AA", "AA", "BB", "BB", "AA", "AA"]
2171 16 : pattern = ["AA", "AA"]
2172 : #elif IK_ENABLED && D1_D1_ENABLED
2173 160 : array = [1_IKC, 1_IKC, 2_IKC, 2_IKC, 1_IKC, 1_IKC]
2174 80 : pattern = [1_IKC, 1_IKC]
2175 : #elif CK_ENABLED && D1_D1_ENABLED
2176 128 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC), (2._CKC,-2._CKC), (2._CKC,-2._CKC), (1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2177 64 : pattern = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2178 : #elif RK_ENABLED && D1_D1_ENABLED
2179 128 : array = [1._RKC, 1._RKC, 2._RKC, 2._RKC, 1._RKC, 1._RKC]
2180 64 : pattern = [1._RKC, 1._RKC]
2181 : #elif LK_ENABLED && D1_D1_ENABLED
2182 160 : array = [.false._LK, .false._LK, .true._LK, .true._LK, .false._LK, .false._LK]
2183 80 : pattern = [.false._LK, .false._LK]
2184 : #endif
2185 400 : instance = [1_IK, -2_IK, -1_IK]
2186 400 : loc_ref = [1_IK, 1_IK, 5_IK]
2187 :
2188 80 : call report(__LINE__, iseq, instance = instance)
2189 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2190 :
2191 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2192 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2193 :
2194 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2195 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2196 :
2197 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2198 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2199 :
2200 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2201 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2202 :
2203 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2204 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2205 :
2206 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2207 :
2208 80 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
2209 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2210 :
2211 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
2212 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2213 :
2214 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
2215 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2216 :
2217 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
2218 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2219 :
2220 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
2221 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2222 :
2223 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
2224 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK, 1_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2225 :
2226 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2227 :
2228 80 : call reset()
2229 :
2230 : #if SK_ENABLED && D0_D0_ENABLED
2231 4 : array = "AABBAA"
2232 4 : pattern = "AA"
2233 : #elif SK_ENABLED && D1_D1_ENABLED
2234 32 : array = ["AA", "AA", "BB", "BB", "AA", "AA"]
2235 16 : pattern = ["AA", "AA"]
2236 : #elif IK_ENABLED && D1_D1_ENABLED
2237 160 : array = [1_IKC, 1_IKC, 2_IKC, 2_IKC, 1_IKC, 1_IKC]
2238 80 : pattern = [1_IKC, 1_IKC]
2239 : #elif CK_ENABLED && D1_D1_ENABLED
2240 128 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC), (2._CKC,-2._CKC), (2._CKC,-2._CKC), (1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2241 64 : pattern = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2242 : #elif RK_ENABLED && D1_D1_ENABLED
2243 128 : array = [1._RKC, 1._RKC, 2._RKC, 2._RKC, 1._RKC, 1._RKC]
2244 64 : pattern = [1._RKC, 1._RKC]
2245 : #elif LK_ENABLED && D1_D1_ENABLED
2246 160 : array = [.false._LK, .false._LK, .true._LK, .true._LK, .false._LK, .false._LK]
2247 80 : pattern = [.false._LK, .false._LK]
2248 : #endif
2249 240 : instance = [-1_IK]
2250 240 : loc_ref = [5_IK]
2251 :
2252 80 : call report(__LINE__, iseq, instance = instance)
2253 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [5_IK]` when `instance` is non-empty but incomprehensive, non-positive with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2254 :
2255 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2256 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [5_IK]` when `instance` is non-empty but incomprehensive, non-positive, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2257 :
2258 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2259 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [5_IK]` when `instance` is non-empty but incomprehensive, non-positive, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2260 :
2261 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2262 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [5_IK]` when `instance` is non-empty but incomprehensive, non-positive, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2263 :
2264 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2265 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [5_IK]` when `instance` is non-empty but incomprehensive, non-positive, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2266 :
2267 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2268 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [5_IK]` when `instance` is non-empty but incomprehensive, non-positive, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2269 :
2270 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2271 :
2272 240 : loc_ref = [1_IK]
2273 :
2274 80 : call report(__LINE__, iseq, instance = instance, blindness = 6_IK)
2275 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK]` when `instance` is non-empty but incomprehensive, non-positive with `blindness = 6_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2276 :
2277 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 6_IK)
2278 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK]` when `instance` is non-empty but incomprehensive, non-positive, with `blindness = 6_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2279 :
2280 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 6_IK)
2281 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK]` when `instance` is non-empty but incomprehensive, non-positive, with `blindness = 6_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2282 :
2283 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 6_IK)
2284 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK]` when `instance` is non-empty but incomprehensive, non-positive, with `blindness = 6_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2285 :
2286 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 6_IK)
2287 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK]` when `instance` is non-empty but incomprehensive, non-positive, with `blindness = 6_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2288 :
2289 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 6_IK)
2290 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": An `array` of length 5 with the beginning and the end matching the double-element vector `pattern` must yield an `loc = [1_IK]` when `instance` is non-empty but incomprehensive, non-positive, with `blindness = 6_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2291 :
2292 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2293 :
2294 80 : call reset()
2295 :
2296 : #if SK_ENABLED && D0_D0_ENABLED
2297 4 : array = "AA"
2298 : #elif SK_ENABLED && D1_D1_ENABLED
2299 12 : array = ["AA"]
2300 : #elif IK_ENABLED && D1_D1_ENABLED
2301 60 : array = [1_IKC]
2302 : #elif CK_ENABLED && D1_D1_ENABLED
2303 48 : array = [(1._CKC,-1._CKC)]
2304 : #elif RK_ENABLED && D1_D1_ENABLED
2305 48 : array = [1._RKC]
2306 : #elif LK_ENABLED && D1_D1_ENABLED
2307 60 : array = [.false._LK]
2308 : #endif
2309 308 : pattern = array
2310 320 : instance = [-1_IK, 3_IK]
2311 240 : loc_ref = [1_IK]
2312 :
2313 80 : call report(__LINE__, iseq, instance = instance)
2314 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2315 :
2316 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2317 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2318 :
2319 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2320 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2321 :
2322 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2323 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2324 :
2325 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2326 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2327 :
2328 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2329 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2330 :
2331 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2332 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2333 :
2334 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2335 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2336 :
2337 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2338 :
2339 80 : call report(__LINE__, iseq, instance = instance, blindness = 1_IK)
2340 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2341 :
2342 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
2343 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2344 :
2345 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
2346 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2347 :
2348 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
2349 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2350 :
2351 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
2352 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2353 :
2354 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
2355 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2356 :
2357 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
2358 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2359 :
2360 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
2361 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 1_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2362 :
2363 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2364 :
2365 80 : call reset()
2366 :
2367 : #if SK_ENABLED && D0_D0_ENABLED
2368 4 : array = "BBAAAA"
2369 4 : pattern = "AA"
2370 : #elif SK_ENABLED && D1_D1_ENABLED
2371 32 : array = ["BB", "BB", "AA", "AA", "AA", "AA"]
2372 16 : pattern = ["AA", "AA"]
2373 : #elif IK_ENABLED && D1_D1_ENABLED
2374 160 : array = [2_IKC, 2_IKC, 1_IKC, 1_IKC, 1_IKC, 1_IKC]
2375 80 : pattern = [1_IKC, 1_IKC]
2376 : #elif CK_ENABLED && D1_D1_ENABLED
2377 128 : array = [(2._CKC,-2._CKC), (2._CKC,-2._CKC), (1._CKC,-1._CKC), (1._CKC,-1._CKC), (1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2378 64 : pattern = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2379 : #elif RK_ENABLED && D1_D1_ENABLED
2380 128 : array = [2._RKC, 2._RKC, 1._RKC, 1._RKC, 1._RKC, 1._RKC]
2381 64 : pattern = [1._RKC, 1._RKC]
2382 : #elif LK_ENABLED && D1_D1_ENABLED
2383 160 : array = [.true._LK, .true._LK, .false._LK, .false._LK, .false._LK, .false._LK]
2384 80 : pattern = [.false._LK, .false._LK]
2385 : #endif
2386 320 : instance = [-1_IK, 3_IK]
2387 320 : loc_ref = [5_IK, 5_IK]
2388 :
2389 80 : call report(__LINE__, iseq, instance = instance)
2390 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2391 :
2392 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2393 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2394 :
2395 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2396 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2397 :
2398 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2399 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2400 :
2401 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2402 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2403 :
2404 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2405 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2406 :
2407 320 : instance = [3, 3]
2408 :
2409 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2410 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2411 :
2412 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2413 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2414 :
2415 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2416 :
2417 320 : instance = [-1_IK, 3_IK]
2418 240 : loc_ref = [5_IK]
2419 :
2420 80 : call report(__LINE__, iseq, instance = instance, blindness = 2_IK)
2421 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed with `blindness = 2_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2422 :
2423 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
2424 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2425 :
2426 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
2427 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2428 :
2429 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
2430 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2431 :
2432 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
2433 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2434 :
2435 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
2436 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2437 :
2438 240 : instance = [2]
2439 :
2440 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 2_IK)
2441 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2442 :
2443 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 2_IK)
2444 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 `loc = [5_IK, 5_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2445 :
2446 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2447 :
2448 80 : call reset()
2449 :
2450 : #if SK_ENABLED && D0_D0_ENABLED
2451 4 : array = "AA"
2452 : #elif SK_ENABLED && D1_D1_ENABLED
2453 12 : array = ["AA"]
2454 : #elif IK_ENABLED && D1_D1_ENABLED
2455 60 : array = [1_IKC]
2456 : #elif CK_ENABLED && D1_D1_ENABLED
2457 48 : array = [(1._CKC,-1._CKC)]
2458 : #elif RK_ENABLED && D1_D1_ENABLED
2459 48 : array = [1._RKC]
2460 : #elif LK_ENABLED && D1_D1_ENABLED
2461 60 : array = [.false._LK]
2462 : #endif
2463 308 : pattern = array
2464 320 : instance = [4_IK, 3_IK]
2465 80 : loc_ref = [integer(IK)::]
2466 :
2467 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2468 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2469 :
2470 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2471 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2472 :
2473 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2474 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2475 :
2476 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2477 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2478 :
2479 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2480 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2481 :
2482 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2483 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2484 :
2485 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2486 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2487 :
2488 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2489 :
2490 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 1_IK)
2491 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2492 :
2493 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 1_IK)
2494 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2495 :
2496 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 1_IK)
2497 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2498 :
2499 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 1_IK)
2500 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2501 :
2502 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 1_IK)
2503 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2504 :
2505 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 1_IK)
2506 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2507 :
2508 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 1_IK)
2509 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with `blindness = 1_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2510 :
2511 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2512 :
2513 80 : call reset()
2514 :
2515 : #if SK_ENABLED && D0_D0_ENABLED
2516 4 : allocate(character(0,SKC) :: array)
2517 4 : pattern = "AA"
2518 : #elif SK_ENABLED && D1_D1_ENABLED
2519 4 : allocate(character(2,SKC) :: array(0))
2520 12 : pattern = ["AA"]
2521 : #elif IK_ENABLED && D1_D1_ENABLED
2522 20 : allocate(array(0))
2523 60 : pattern = [1_IKC]
2524 : #elif CK_ENABLED && D1_D1_ENABLED
2525 16 : allocate(array(0))
2526 48 : pattern = [(1._CKC,-1._CKC)]
2527 : #elif RK_ENABLED && D1_D1_ENABLED
2528 16 : allocate(array(0))
2529 48 : pattern = [1._RKC]
2530 : #elif LK_ENABLED && D1_D1_ENABLED
2531 20 : allocate(array(0))
2532 60 : pattern = [.false._LK]
2533 : #endif
2534 80 : loc_ref = [integer(IK)::]
2535 320 : instance = [30_IK, 3_IK]
2536 :
2537 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2538 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2539 :
2540 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2541 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2542 :
2543 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2544 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2545 :
2546 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2547 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2548 :
2549 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2550 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2551 :
2552 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2553 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2554 :
2555 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2556 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2557 :
2558 240 : instance = [1_IK]
2559 :
2560 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2561 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2562 :
2563 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2564 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2565 :
2566 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2567 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2568 :
2569 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2570 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2571 :
2572 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2573 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2574 :
2575 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2576 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2577 :
2578 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2579 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2580 :
2581 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2582 :
2583 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 4_IK)
2584 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 4_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2585 :
2586 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 4_IK)
2587 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 4_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2588 :
2589 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 4_IK)
2590 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 4_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2591 :
2592 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 4_IK)
2593 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 4_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2594 :
2595 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 4_IK)
2596 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 4_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2597 :
2598 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 4_IK)
2599 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 4_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2600 :
2601 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 4_IK)
2602 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 4_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2603 :
2604 240 : instance = [1_IK]
2605 :
2606 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 4_IK)
2607 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 4_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2608 :
2609 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 4_IK)
2610 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 4_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2611 :
2612 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 4_IK)
2613 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 4_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2614 :
2615 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 4_IK)
2616 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 4_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2617 :
2618 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 4_IK)
2619 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 4_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2620 :
2621 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 4_IK)
2622 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 4_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2623 :
2624 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 4_IK)
2625 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `blindness = 4_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2626 :
2627 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2628 :
2629 80 : call reset()
2630 :
2631 : #if SK_ENABLED && D0_D0_ENABLED
2632 4 : array = "AABBCCAA"
2633 4 : pattern = "AA"
2634 : #elif SK_ENABLED && D1_D1_ENABLED
2635 40 : array = ["AA", "AA", "BB", "BB", "CC", "CC", "AA", "AA"]
2636 16 : pattern = ["AA", "AA"]
2637 : #elif IK_ENABLED && D1_D1_ENABLED
2638 200 : array = [1_IKC, 1_IKC, 2_IKC, 2_IKC, 3_IKC, 3_IKC, 1_IKC, 1_IKC]
2639 80 : pattern = [1_IKC, 1_IKC]
2640 : #elif CK_ENABLED && D1_D1_ENABLED
2641 160 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC), (2._CKC,-2._CKC), (2._CKC,-2._CKC), (3._CKC,-3._CKC), (3._CKC,-3._CKC), (1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2642 64 : pattern = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2643 : #elif RK_ENABLED && D1_D1_ENABLED
2644 160 : array = [1._RKC, 1._RKC, 2._RKC, 2._RKC, 3._RKC, 3._RKC, 1._RKC, 1._RKC]
2645 64 : pattern = [1._RKC, 1._RKC]
2646 : #elif LK_ENABLED && D1_D1_ENABLED
2647 200 : array = [.false._LK, .false._LK, .true._LK, .true._LK, .true._LK, .true._LK, .false._LK, .false._LK]
2648 80 : pattern = [.false._LK, .false._LK]
2649 : #endif
2650 320 : instance = [1_IK, -1_IK]
2651 320 : loc_ref = [1_IK, 7_IK]
2652 :
2653 80 : call report(__LINE__, iseq)
2654 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 `loc = [1_IK, 7_IK]` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2655 :
2656 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2657 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, -1_IK]` with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2658 :
2659 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2660 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, -1_IK]` with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2661 :
2662 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2663 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, -1_IK]` with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2664 :
2665 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2666 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, -1_IK]` with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2667 :
2668 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2669 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, -1_IK]` with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2670 :
2671 320 : instance = [1_IK, 2_IK]
2672 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2673 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, 2_IK]` with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2674 :
2675 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2676 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, 2_IK]` with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2677 :
2678 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2679 :
2680 80 : call report(__LINE__, iseq, blindness = 6_IK)
2681 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 `loc = [1_IK, 7_IK]` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2682 :
2683 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 6_IK)
2684 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, -1_IK]` with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2685 :
2686 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 6_IK)
2687 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, -1_IK]` with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2688 :
2689 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 6_IK)
2690 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, -1_IK]` with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2691 :
2692 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 6_IK)
2693 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, -1_IK]` with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2694 :
2695 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 6_IK)
2696 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, -1_IK]` with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2697 :
2698 320 : instance = [1_IK, 2_IK]
2699 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 6_IK)
2700 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, 2_IK]` with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2701 :
2702 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 6_IK)
2703 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 `loc = [1_IK, 7_IK]` when `instance = [1_IK, 2_IK]` with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2704 :
2705 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2706 :
2707 80 : call reset()
2708 :
2709 : #if SK_ENABLED && D0_D0_ENABLED
2710 4 : array = "AAAA"
2711 4 : pattern = "XX"
2712 : #elif SK_ENABLED && D1_D1_ENABLED
2713 16 : array = ["AA", "AA"]
2714 12 : pattern = ["XX"]
2715 : #elif IK_ENABLED && D1_D1_ENABLED
2716 80 : array = [1_IKC, 1_IKC]
2717 60 : pattern = [0_IKC]
2718 : #elif CK_ENABLED && D1_D1_ENABLED
2719 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2720 48 : pattern = [(0._CKC,0._CKC)]
2721 : #elif RK_ENABLED && D1_D1_ENABLED
2722 64 : array = [1._RKC, 1._RKC]
2723 48 : pattern = [0._RKC]
2724 : #elif LK_ENABLED && D1_D1_ENABLED
2725 80 : array = [.false._LK, .false._LK]
2726 60 : pattern = [.true._LK]
2727 : #endif
2728 320 : instance = [10_IK, 3_IK]
2729 80 : loc_ref = [integer(IK)::]
2730 :
2731 80 : call report(__LINE__, iseq)
2732 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2733 :
2734 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2735 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2736 :
2737 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2738 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2739 :
2740 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2741 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2742 :
2743 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2744 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2745 :
2746 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2747 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2748 :
2749 320 : instance = [3_IK, 10_IK]
2750 :
2751 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2752 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2753 :
2754 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2755 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2756 :
2757 240 : instance = [1_IK]
2758 :
2759 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2760 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2761 :
2762 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2763 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2764 :
2765 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2766 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2767 :
2768 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2769 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2770 :
2771 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2772 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2773 :
2774 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2775 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2776 :
2777 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2778 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2779 :
2780 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2781 :
2782 80 : call report(__LINE__, iseq)
2783 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` with `blindness = 2_IK`, setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2784 :
2785 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
2786 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, `blindness = 2_IK`, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2787 :
2788 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
2789 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, `blindness = 2_IK`, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2790 :
2791 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 2_IK)
2792 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, `blindness = 2_IK`, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2793 :
2794 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
2795 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, `blindness = 2_IK`, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2796 :
2797 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
2798 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, `blindness = 2_IK`, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2799 :
2800 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 2_IK)
2801 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, `blindness = 2_IK`, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2802 :
2803 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
2804 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, `blindness = 2_IK`, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2805 :
2806 240 : instance = [1_IK]
2807 :
2808 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
2809 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, `blindness = 2_IK`, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2810 :
2811 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
2812 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, `blindness = 2_IK`, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2813 :
2814 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 2_IK)
2815 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, `blindness = 2_IK`, with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2816 :
2817 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
2818 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, `blindness = 2_IK`, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2819 :
2820 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
2821 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, `blindness = 2_IK`, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2822 :
2823 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 2_IK)
2824 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, `blindness = 2_IK`, with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2825 :
2826 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
2827 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with non-matching `pattern` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty, and sensible, `blindness = 2_IK`, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2828 :
2829 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2830 :
2831 80 : call reset()
2832 :
2833 : #if SK_ENABLED && D0_D0_ENABLED
2834 4 : array = "AXAXA"
2835 4 : pattern = "X"
2836 : #elif SK_ENABLED && D1_D1_ENABLED
2837 28 : array = ["AA", "XX", "AA", "XX", "AA"]
2838 12 : pattern = ["XX"]
2839 : #elif IK_ENABLED && D1_D1_ENABLED
2840 140 : array = [1_IKC, 0_IKC, 1_IKC, 0_IKC, 1_IKC]
2841 60 : pattern = [0_IKC]
2842 : #elif CK_ENABLED && D1_D1_ENABLED
2843 112 : array = [(1._CKC,-1._CKC), (0._CKC,0._CKC), (1._CKC,-1._CKC), (0._CKC,0._CKC), (1._CKC,-1._CKC)]
2844 48 : pattern = [(0._CKC,0._CKC)]
2845 : #elif RK_ENABLED && D1_D1_ENABLED
2846 112 : array = [1._RKC, 0._RKC, 1._RKC, 0._RKC, 1._RKC]
2847 48 : pattern = [0._RKC]
2848 : #elif LK_ENABLED && D1_D1_ENABLED
2849 140 : array = [.false._LK, .true._LK, .false._LK, .true._LK, .false._LK]
2850 60 : pattern = [.true._LK]
2851 : #endif
2852 320 : loc_ref = [2_IK, 4_IK]
2853 :
2854 320 : instance = [1_IK, -1_IK]
2855 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2856 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2857 :
2858 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2859 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2860 :
2861 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2862 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2863 :
2864 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2865 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2866 :
2867 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2868 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2869 :
2870 320 : instance = [1_IK, 2_IK]
2871 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2872 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance = [1_IK, 2_IK]` with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2873 :
2874 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2875 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance = [1_IK, 2_IK]` with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2876 :
2877 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2878 :
2879 320 : instance = [1_IK, -1_IK]
2880 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
2881 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2882 :
2883 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
2884 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2885 :
2886 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
2887 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2888 :
2889 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
2890 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2891 :
2892 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
2893 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2894 :
2895 320 : instance = [1_IK, 2_IK]
2896 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 2_IK)
2897 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance = [1_IK, 2_IK]` with `blindness = 2_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2898 :
2899 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 2_IK)
2900 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with two `pattern` occurrences must yield `loc_ref = [2_IK, 4_IK]` when `instance = [1_IK, 2_IK]` with `blindness = 2_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2901 :
2902 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2903 :
2904 80 : call reset()
2905 :
2906 : #if SK_ENABLED && D0_D0_ENABLED
2907 4 : array = "AAA"
2908 4 : pattern = "AA"
2909 : #elif SK_ENABLED && D1_D1_ENABLED
2910 16 : array = ["AA", "AA"]
2911 12 : pattern = ["AA"]
2912 : #elif IK_ENABLED && D1_D1_ENABLED
2913 80 : array = [1_IKC, 1_IKC]
2914 60 : pattern = [1_IKC]
2915 : #elif CK_ENABLED && D1_D1_ENABLED
2916 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
2917 48 : pattern = [(1._CKC,-1._CKC)]
2918 : #elif RK_ENABLED && D1_D1_ENABLED
2919 64 : array = [1._RKC, 1._RKC]
2920 48 : pattern = [1._RKC]
2921 : #elif LK_ENABLED && D1_D1_ENABLED
2922 80 : array = [.false._LK, .false._LK]
2923 60 : pattern = [.false._LK]
2924 : #endif
2925 320 : instance = [10_IK, 3_IK]
2926 80 : loc_ref = [integer(IK)::]
2927 :
2928 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
2929 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2930 :
2931 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
2932 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2933 :
2934 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
2935 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2936 :
2937 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
2938 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2939 :
2940 320 : instance = [3_IK, 10_IK]
2941 :
2942 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
2943 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2944 :
2945 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
2946 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2947 :
2948 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
2949 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2950 :
2951 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2952 :
2953 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
2954 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `blindness = 2_IK`, `sorted = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2955 :
2956 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
2957 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `blindness = 2_IK`, `sorted = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2958 :
2959 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 2_IK)
2960 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `blindness = 2_IK`, `positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2961 :
2962 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
2963 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `blindness = 2_IK`, `positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2964 :
2965 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
2966 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `blindness = 2_IK`, `sorted = .true._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2967 :
2968 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 2_IK)
2969 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `blindness = 2_IK`, `sorted = .true._LK, positive = .true.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2970 :
2971 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
2972 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with a matching `pattern` must yield `loc = [integer(IK)::]` when `instance = [0_IK, 3_IK]` with `blindness = 2_IK`, `sorted = .false._LK, positive = .false.` with setLocEnabled = "//getStr(setLocEnabled)//".", int(__LINE__, IK))
2973 :
2974 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2975 :
2976 80 : call reset()
2977 :
2978 : #if SK_ENABLED && D0_D0_ENABLED
2979 4 : array = "AA"
2980 4 : pattern = ""
2981 : #elif SK_ENABLED && D1_D1_ENABLED
2982 16 : array = ["AA", "AA"]
2983 4 : allocate(character(2,SKC) :: pattern(0))
2984 : #elif IK_ENABLED && D1_D1_ENABLED
2985 80 : array = [1_IKC, 1_IKC]
2986 20 : allocate(pattern(0))
2987 : #elif CK_ENABLED && D1_D1_ENABLED
2988 64 : array = [1._CKC, 1._CKC]
2989 16 : allocate(pattern(0))
2990 : #elif RK_ENABLED && D1_D1_ENABLED
2991 64 : array = [1._RKC, 1._RKC]
2992 16 : allocate(pattern(0))
2993 : #elif LK_ENABLED && D1_D1_ENABLED
2994 80 : array = [.false._LK, .false._LK]
2995 20 : allocate(pattern(0))
2996 : #endif
2997 80 : loc_ref = [integer(IK)::]
2998 80 : allocate(instance(0))
2999 :
3000 80 : call report(__LINE__, iseq)
3001 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]`.", int(__LINE__, IK))
3002 :
3003 80 : call report(__LINE__, iseq, instance = instance)
3004 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is empty.", int(__LINE__, IK))
3005 :
3006 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
3007 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is empty with `sorted = .true.`.", int(__LINE__, IK))
3008 :
3009 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
3010 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is empty with `sorted = .false.`.", int(__LINE__, IK))
3011 :
3012 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
3013 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is empty with `positive = .true.`.", int(__LINE__, IK))
3014 :
3015 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
3016 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is empty with `positive = .false.`.", int(__LINE__, IK))
3017 :
3018 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
3019 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is empty with `sorted = .true._LK, positive = .true.`.", int(__LINE__, IK))
3020 :
3021 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
3022 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is empty with `sorted = .false._LK, positive = .true.`.", int(__LINE__, IK))
3023 :
3024 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
3025 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is empty with `sorted = .true._LK, positive = .false.`.", int(__LINE__, IK))
3026 :
3027 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
3028 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is empty with `sorted = .false._LK, positive = .false.`.", int(__LINE__, IK))
3029 :
3030 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3031 :
3032 80 : call reset()
3033 :
3034 : #if SK_ENABLED && D0_D0_ENABLED
3035 4 : array = "AA"
3036 4 : pattern = ""
3037 : #elif SK_ENABLED && D1_D1_ENABLED
3038 16 : array = ["AA", "AA"]
3039 4 : allocate(character(2,SKC) :: pattern(0))
3040 : #elif IK_ENABLED && D1_D1_ENABLED
3041 80 : array = [1_IKC, 1_IKC]
3042 20 : allocate(pattern(0))
3043 : #elif CK_ENABLED && D1_D1_ENABLED
3044 64 : array = [1._CKC, 1._CKC]
3045 16 : allocate(pattern(0))
3046 : #elif RK_ENABLED && D1_D1_ENABLED
3047 64 : array = [1._RKC, 1._RKC]
3048 16 : allocate(pattern(0))
3049 : #elif LK_ENABLED && D1_D1_ENABLED
3050 80 : array = [.false._LK, .false._LK]
3051 20 : allocate(pattern(0))
3052 : #endif
3053 80 : loc_ref = [integer(IK)::]
3054 240 : instance = [1_IK]
3055 :
3056 80 : call report(__LINE__, iseq)
3057 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]`.", int(__LINE__, IK))
3058 :
3059 80 : call report(__LINE__, iseq, instance = instance)
3060 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty.", int(__LINE__, IK))
3061 :
3062 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
3063 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `sorted = .true.`.", int(__LINE__, IK))
3064 :
3065 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
3066 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `sorted = .false.`.", int(__LINE__, IK))
3067 :
3068 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
3069 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `positive = .true.`.", int(__LINE__, IK))
3070 :
3071 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
3072 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `positive = .false.`.", int(__LINE__, IK))
3073 :
3074 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
3075 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `sorted = .true._LK, positive = .true.`.", int(__LINE__, IK))
3076 :
3077 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK)
3078 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `sorted = .false._LK, positive = .true.`.", int(__LINE__, IK))
3079 :
3080 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
3081 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `sorted = .true._LK, positive = .false.`.", int(__LINE__, IK))
3082 :
3083 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
3084 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `sorted = .false._LK, positive = .false.`.", int(__LINE__, IK))
3085 :
3086 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3087 :
3088 80 : call report(__LINE__, iseq, blindness = 2_IK)
3089 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` with `blindness = 2_IK`.", int(__LINE__, IK))
3090 :
3091 80 : call report(__LINE__, iseq, instance = instance, blindness = 2_IK)
3092 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `blindness = 2_IK`.", int(__LINE__, IK))
3093 :
3094 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
3095 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `blindness = 2_IK`, `sorted = .true.`.", int(__LINE__, IK))
3096 :
3097 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
3098 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `blindness = 2_IK`, `sorted = .false.`.", int(__LINE__, IK))
3099 :
3100 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 2_IK)
3101 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `blindness = 2_IK`, `positive = .true.`.", int(__LINE__, IK))
3102 :
3103 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
3104 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `blindness = 2_IK`, `positive = .false.`.", int(__LINE__, IK))
3105 :
3106 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 2_IK)
3107 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `blindness = 2_IK`, `sorted = .true._LK, positive = .true.`.", int(__LINE__, IK))
3108 :
3109 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .true._LK, blindness = 2_IK)
3110 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `blindness = 2_IK`, `sorted = .false._LK, positive = .true.`.", int(__LINE__, IK))
3111 :
3112 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
3113 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `blindness = 2_IK`, `sorted = .true._LK, positive = .false.`.", int(__LINE__, IK))
3114 :
3115 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
3116 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with empty `pattern` must yield `loc = [integer(IK)::]` when `instance` is non-empty with `blindness = 2_IK`, `sorted = .false._LK, positive = .false.`.", int(__LINE__, IK))
3117 :
3118 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3119 :
3120 80 : call reset()
3121 :
3122 : #if SK_ENABLED && D0_D0_ENABLED
3123 4 : array = "AA"
3124 : #elif SK_ENABLED && D1_D1_ENABLED
3125 16 : array = ["AA", "AA"]
3126 : #elif IK_ENABLED && D1_D1_ENABLED
3127 80 : array = [1_IKC, 1_IKC]
3128 : #elif CK_ENABLED && D1_D1_ENABLED
3129 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
3130 : #elif RK_ENABLED && D1_D1_ENABLED
3131 64 : array = [1._RKC, 1._RKC]
3132 : #elif LK_ENABLED && D1_D1_ENABLED
3133 80 : array = [.false._LK, .false._LK]
3134 : #endif
3135 384 : pattern = array
3136 320 : instance = [-1_IK, 3_IK]
3137 240 : loc_ref = [1_IK]
3138 :
3139 80 : call report(__LINE__, iseq, instance = instance)
3140 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed.", int(__LINE__, IK))
3141 :
3142 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
3143 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true.`.", int(__LINE__, IK))
3144 :
3145 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
3146 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false.`.", int(__LINE__, IK))
3147 :
3148 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
3149 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .true.`.", int(__LINE__, IK))
3150 :
3151 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
3152 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `positive = .false.`.", int(__LINE__, IK))
3153 :
3154 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
3155 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .false.`.", int(__LINE__, IK))
3156 :
3157 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
3158 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .true._LK, positive = .true.`.", int(__LINE__, IK))
3159 :
3160 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
3161 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `sorted = .false._LK, positive = .false.`.", int(__LINE__, IK))
3162 :
3163 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3164 :
3165 80 : call report(__LINE__, iseq, instance = instance, blindness = 2_IK)
3166 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed with `blindness = 2_IK`.", int(__LINE__, IK))
3167 :
3168 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
3169 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, with `sorted = .true.`.", int(__LINE__, IK))
3170 :
3171 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
3172 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, with `sorted = .false.`.", int(__LINE__, IK))
3173 :
3174 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 2_IK)
3175 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, with `positive = .true.`.", int(__LINE__, IK))
3176 :
3177 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
3178 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, with `positive = .false.`.", int(__LINE__, IK))
3179 :
3180 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
3181 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, with `sorted = .true._LK, positive = .false.`.", int(__LINE__, IK))
3182 :
3183 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 2_IK)
3184 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, with `sorted = .true._LK, positive = .true.`.", int(__LINE__, IK))
3185 :
3186 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
3187 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [1_IK]` when `instance` is non-empty but incomprehensive, redundant, non-positive, and mixed, with `blindness = 2_IK`, with `sorted = .false._LK, positive = .false.`.", int(__LINE__, IK))
3188 :
3189 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3190 :
3191 80 : call reset()
3192 :
3193 : #if SK_ENABLED && D0_D0_ENABLED
3194 4 : array = "AA"
3195 : #elif SK_ENABLED && D1_D1_ENABLED
3196 16 : array = ["AA", "AA"]
3197 : #elif IK_ENABLED && D1_D1_ENABLED
3198 80 : array = [1_IKC, 1_IKC]
3199 : #elif CK_ENABLED && D1_D1_ENABLED
3200 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
3201 : #elif RK_ENABLED && D1_D1_ENABLED
3202 64 : array = [1._RKC, 1._RKC]
3203 : #elif LK_ENABLED && D1_D1_ENABLED
3204 80 : array = [.false._LK, .false._LK]
3205 : #endif
3206 384 : pattern = array
3207 320 : instance = [10_IK, 3_IK]
3208 80 : loc_ref = [integer(IK)::]
3209 :
3210 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
3211 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.`.", int(__LINE__, IK))
3212 :
3213 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
3214 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.`.", int(__LINE__, IK))
3215 :
3216 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
3217 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.`.", int(__LINE__, IK))
3218 :
3219 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
3220 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.`.", int(__LINE__, IK))
3221 :
3222 320 : instance = [3_IK, 10_IK]
3223 :
3224 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
3225 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.`.", int(__LINE__, IK))
3226 :
3227 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
3228 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.`.", int(__LINE__, IK))
3229 :
3230 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
3231 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.`.", int(__LINE__, IK))
3232 :
3233 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3234 :
3235 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 2_IK)
3236 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK, `sorted = .true.`.", int(__LINE__, IK))
3237 :
3238 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 2_IK)
3239 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK, `sorted = .false.`.", int(__LINE__, IK))
3240 :
3241 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 2_IK)
3242 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK, `positive = .true.`.", int(__LINE__, IK))
3243 :
3244 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 2_IK)
3245 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK, `positive = .false.`.", int(__LINE__, IK))
3246 :
3247 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 2_IK)
3248 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK, `sorted = .true._LK, positive = .false.`.", int(__LINE__, IK))
3249 :
3250 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 2_IK)
3251 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK, `sorted = .true._LK, positive = .true.`.", int(__LINE__, IK))
3252 :
3253 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 2_IK)
3254 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` the same as the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 2_IK, `sorted = .false._LK, positive = .false.`.", int(__LINE__, IK))
3255 :
3256 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3257 :
3258 80 : call reset()
3259 :
3260 : #if SK_ENABLED && D0_D0_ENABLED
3261 4 : array = "AA"
3262 4 : pattern = array//array
3263 : #elif SK_ENABLED && D1_D1_ENABLED
3264 16 : array = ["AA", "AA"]
3265 48 : pattern = [array, array]
3266 : #elif IK_ENABLED && D1_D1_ENABLED
3267 80 : array = [1_IKC, 1_IKC]
3268 240 : pattern = [array, array]
3269 : #elif CK_ENABLED && D1_D1_ENABLED
3270 64 : array = [(1._CKC,-1._CKC), (1._CKC,-1._CKC)]
3271 192 : pattern = [array, array]
3272 : #elif RK_ENABLED && D1_D1_ENABLED
3273 64 : array = [1._RKC, 1._RKC]
3274 192 : pattern = [array, array]
3275 : #elif LK_ENABLED && D1_D1_ENABLED
3276 80 : array = [.false._LK, .false._LK]
3277 240 : pattern = [array, array]
3278 : #endif
3279 320 : instance = [1_IK, 3_IK]
3280 80 : loc_ref = [integer(IK)::]
3281 :
3282 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK)
3283 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true.`.", int(__LINE__, IK))
3284 :
3285 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK)
3286 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false.`.", int(__LINE__, IK))
3287 :
3288 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK)
3289 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .true.`.", int(__LINE__, IK))
3290 :
3291 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK)
3292 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `positive = .false.`.", int(__LINE__, IK))
3293 :
3294 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK)
3295 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .false.`.", int(__LINE__, IK))
3296 :
3297 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK)
3298 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .true._LK, positive = .true.`.", int(__LINE__, IK))
3299 :
3300 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK)
3301 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `sorted = .false._LK, positive = .false.`.", int(__LINE__, IK))
3302 :
3303 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3304 :
3305 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, blindness = 20_IK)
3306 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 20_IK`, `sorted = .true.`.", int(__LINE__, IK))
3307 :
3308 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, blindness = 20_IK)
3309 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 20_IK`, `sorted = .false.`.", int(__LINE__, IK))
3310 :
3311 80 : call report(__LINE__, iseq, instance = instance, positive = .true._LK, blindness = 20_IK)
3312 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 20_IK`, `positive = .true.`.", int(__LINE__, IK))
3313 :
3314 80 : call report(__LINE__, iseq, instance = instance, positive = .false._LK, blindness = 20_IK)
3315 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 20_IK`, `positive = .false.`.", int(__LINE__, IK))
3316 :
3317 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .false._LK, blindness = 20_IK)
3318 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 20_IK`, `sorted = .true._LK, positive = .false.`.", int(__LINE__, IK))
3319 :
3320 80 : call report(__LINE__, iseq, instance = instance, sorted = .true._LK, positive = .true._LK, blindness = 20_IK)
3321 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 20_IK`, `sorted = .true._LK, positive = .true.`.", int(__LINE__, IK))
3322 :
3323 80 : call report(__LINE__, iseq, instance = instance, sorted = .false._LK, positive = .false._LK, blindness = 20_IK)
3324 80 : call test%assert(assertion, PROCEDURE_NAME//SK_": A non-empty `array` with `pattern` larger than the `array` must yield `loc = [integer(IK)::]` when `instance` is ordered, positive, non-empty but non-sensible, with `blindness = 20_IK`, `sorted = .false._LK, positive = .false.`.", int(__LINE__, IK))
3325 :
3326 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3327 :
3328 :
3329 80 : end subroutine
3330 :
3331 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3332 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3333 :
3334 : subroutine report ( line & ! LCOV_EXCL_LINE
3335 : , iseq & ! LCOV_EXCL_LINE
3336 : , instance & ! LCOV_EXCL_LINE
3337 : , blindness & ! LCOV_EXCL_LINE
3338 : , positive & ! LCOV_EXCL_LINE
3339 : , sorted & ! LCOV_EXCL_LINE
3340 : )
3341 : integer, intent(in) :: line
3342 : logical(LK) , external , optional :: iseq
3343 : integer(IK) , intent(in), optional, contiguous :: instance(:)
3344 : integer(IK) , intent(in), optional :: blindness
3345 : logical(LK) , intent(in), optional :: positive
3346 : logical(LK) , intent(in), optional :: sorted
3347 : logical(LK) :: sorted_def, positive_def
3348 : integer(IK) :: blindness_def, nloc
3349 :
3350 28800 : sorted_def = .false._LK; if (present(sorted)) sorted_def = sorted
3351 28800 : positive_def = .false._LK; if (present(positive)) positive_def = positive
3352 28800 : blindness_def = 1_IK; if (present(blindness)) blindness_def = blindness
3353 :
3354 28800 : if (setLocEnabled) then
3355 14400 : if (present(iseq) .and. present(instance)) then
3356 6860 : call setLoc(loc, nloc, array, pattern, iseq, instance, sorted_def, positive_def, blindness_def)
3357 7540 : elseif (present(instance)) then
3358 6860 : call setLoc(loc, nloc, array, pattern, instance, sorted_def, positive_def, blindness_def)
3359 680 : elseif (present(iseq)) then
3360 340 : call setLoc(loc, nloc, array, pattern, iseq, blindness_def)
3361 : else
3362 340 : call setLoc(loc, nloc, array, pattern, blindness_def)
3363 : end if
3364 : else
3365 14400 : if (present(iseq) .and. present(instance) .and. present(sorted) .and. present(positive)) then
3366 8300 : loc = getLoc(array, pattern, iseq = iseq, instance = instance, sorted = sorted, positive = positive, blindness = blindness)
3367 11600 : elseif (present(iseq) .and. present(instance) .and. present(sorted) .and. .not. present(positive)) then
3368 5600 : loc = getLoc(array, pattern, iseq = iseq, instance = instance, sorted = sorted, blindness = blindness)
3369 9760 : elseif (present(iseq) .and. present(instance) .and. .not. present(sorted) .and. present(positive)) then
3370 4920 : loc = getLoc(array, pattern, iseq = iseq, instance = instance, positive = positive, blindness = blindness)
3371 8080 : elseif (present(iseq) .and. present(instance) .and. .not. present(sorted) .and. .not. present(positive)) then
3372 1940 : loc = getLoc(array, pattern, iseq = iseq, instance = instance, blindness = blindness)
3373 7540 : elseif (present(iseq) .and. .not. present(instance) .and. .not. present(sorted) .and. .not. present(positive)) then
3374 1080 : loc = getLoc(array, pattern, iseq = iseq, blindness = blindness)
3375 7200 : elseif (.not. present(iseq) .and. present(instance) .and. present(sorted) .and. present(positive)) then
3376 8300 : loc = getLoc(array, pattern, instance = instance, sorted = sorted, positive = positive, blindness = blindness)
3377 4400 : elseif (.not. present(iseq) .and. present(instance) .and. present(sorted) .and. .not. present(positive)) then
3378 5600 : loc = getLoc(array, pattern, instance = instance, sorted = sorted, blindness = blindness)
3379 2560 : elseif (.not. present(iseq) .and. present(instance) .and. .not. present(sorted) .and. present(positive)) then
3380 4920 : loc = getLoc(array, pattern, instance = instance, positive = positive, blindness = blindness)
3381 880 : elseif (.not. present(iseq) .and. present(instance) .and. .not. present(sorted) .and. .not. present(positive)) then
3382 1940 : loc = getLoc(array, pattern, instance = instance, blindness = blindness)
3383 340 : elseif (.not. present(iseq) .and. .not. present(instance) .and. .not. present(sorted) .and. .not. present(positive)) then
3384 1080 : loc = getLoc(array, pattern, blindness = blindness)
3385 : else
3386 : error stop PROCEDURE_NAME//SK_": Unrecognized interface in testing." ! LCOV_EXCL_LINE
3387 : end if
3388 14400 : nloc = size(loc, 1, IK)
3389 : end if
3390 :
3391 : ! Report test results if needed.
3392 :
3393 : !write(*,*) setLocEnabled, present(instance), present(sorted), present(positive)
3394 : !write(*,*) array
3395 : !write(*,*) pattern
3396 : !write(*,*) loc
3397 : !write(*,*) loc_ref
3398 :
3399 28800 : assertion = assertion .and. nloc == size(loc_ref, 1, IK)
3400 58560 : if (assertion .and. 0_IK < nloc) assertion = assertion .and. all(loc(1 : nloc) == loc_ref)
3401 :
3402 28800 : if (test%traceable .and. .not. assertion) then
3403 : ! LCOV_EXCL_START
3404 : call test%disp%skip()
3405 : call test%disp%show("setLocEnabled")
3406 : call test%disp%show( setLocEnabled )
3407 : call test%disp%show("array")
3408 : call test%disp%show( array )
3409 : call test%disp%show("pattern")
3410 : call test%disp%show( pattern )
3411 : call test%disp%show("nloc")
3412 : call test%disp%show( nloc )
3413 : call test%disp%show("loc_ref")
3414 : call test%disp%show( loc_ref )
3415 : call test%disp%show("loc(1:nloc)")
3416 : call test%disp%show( loc(1:nloc) )
3417 : call test%disp%show("present(iseq)")
3418 : call test%disp%show( present(iseq) )
3419 : call test%disp%show("present(instance)")
3420 : call test%disp%show( present(instance) )
3421 : if (present(instance)) then
3422 : call test%disp%show("instance")
3423 : call test%disp%show( instance )
3424 : end if
3425 : call test%disp%show("present(positive)")
3426 : call test%disp%show( present(positive) )
3427 : if (present(positive)) then
3428 : call test%disp%show("positive")
3429 : call test%disp%show( positive )
3430 : end if
3431 : call test%disp%show("present(sorted)")
3432 : call test%disp%show( present(sorted) )
3433 : if (present(sorted)) then
3434 : call test%disp%show("sorted")
3435 : call test%disp%show( sorted )
3436 : end if
3437 : call test%disp%show("present(blindness)")
3438 : call test%disp%show( present(blindness) )
3439 : if (present(blindness)) then
3440 : call test%disp%show("blindness")
3441 : call test%disp%show( blindness )
3442 : end if
3443 : call test%disp%skip()
3444 : ! LCOV_EXCL_STOP
3445 : end if
3446 :
3447 28800 : if (nloc /= size(loc_ref, 1, IK)) call test%assert(assertion, PROCEDURE_NAME//SK_": The condition `nloc = size(loc_ref) must hold.", int(line, IK))
3448 :
3449 28800 : end subroutine
3450 : #else
3451 : !%%%%%%%%%%%%%%%%%%%%%%%%
3452 : #error "Unrecognized interface."
3453 : !%%%%%%%%%%%%%%%%%%%%%%%%
3454 : #endif
3455 : #undef IS_EQUAL
3456 : #undef ALL
|
