CoCalc -- Int128VectorTests.java

GitHub Repository: PojavLauncherTeam/mobile
Path: blob/master/test/jdk/jdk/incubator/vector/Int128VectorTests.java
⁴¹⁷¹⁰ views
1
/*
2
 * Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved.
3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
 *
5
 * This code is free software; you can redistribute it and/or modify it
6
 * under the terms of the GNU General Public License version 2 only, as
7
 * published by the Free Software Foundation.
8
 *
9
 * This code is distributed in the hope that it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12
 * version 2 for more details (a copy is included in the LICENSE file that
13
 * accompanied this code).
14
 *
15
 * You should have received a copy of the GNU General Public License version
16
 * 2 along with this work; if not, write to the Free Software Foundation,
17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18
 *
19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20
 * or visit www.oracle.com if you need additional information or have any
21
 * questions.
22
 */
23

24
/*
25
 * @test
26
 * @modules jdk.incubator.vector
27
 * @run testng/othervm -ea -esa -Xbatch -XX:-TieredCompilation Int128VectorTests
28
 */
29

30
// -- This file was mechanically generated: Do not edit! -- //
31

32
import jdk.incubator.vector.VectorShape;
33
import jdk.incubator.vector.VectorSpecies;
34
import jdk.incubator.vector.VectorShuffle;
35
import jdk.incubator.vector.VectorMask;
36
import jdk.incubator.vector.VectorOperators;
37
import jdk.incubator.vector.Vector;
38

39
import jdk.incubator.vector.IntVector;
40

41
import org.testng.Assert;
42
import org.testng.annotations.DataProvider;
43
import org.testng.annotations.Test;
44

45
import java.lang.Integer;
46
import java.util.List;
47
import java.util.Arrays;
48
import java.util.function.BiFunction;
49
import java.util.function.IntFunction;
50
import java.util.Objects;
51
import java.util.stream.Collectors;
52
import java.util.stream.Stream;
53

54
@Test
55
public class Int128VectorTests extends AbstractVectorTest {
56

57
    static final VectorSpecies<Integer> SPECIES =
58
                IntVector.SPECIES_128;
59

60
    static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
61

62

63
    static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 128);
64

65
    static final int BUFFER_SIZE = Integer.getInteger("jdk.incubator.vector.test.buffer-size", BUFFER_REPS * (128 / 8));
66

67
    interface FUnOp {
68
        int apply(int a);
69
    }
70

71
    static void assertArraysEquals(int[] r, int[] a, FUnOp f) {
72
        int i = 0;
73
        try {
74
            for (; i < a.length; i++) {
75
                Assert.assertEquals(r[i], f.apply(a[i]));
76
            }
77
        } catch (AssertionError e) {
78
            Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
79
        }
80
    }
81

82
    interface FUnArrayOp {
83
        int[] apply(int a);
84
    }
85

86
    static void assertArraysEquals(int[] r, int[] a, FUnArrayOp f) {
87
        int i = 0;
88
        try {
89
            for (; i < a.length; i += SPECIES.length()) {
90
                Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
91
                  f.apply(a[i]));
92
            }
93
        } catch (AssertionError e) {
94
            int[] ref = f.apply(a[i]);
95
            int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
96
            Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
97
              + ", res: " + Arrays.toString(res)
98
              + "), at index #" + i);
99
        }
100
    }
101

102
    static void assertArraysEquals(int[] r, int[] a, boolean[] mask, FUnOp f) {
103
        int i = 0;
104
        try {
105
            for (; i < a.length; i++) {
106
                Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
107
            }
108
        } catch (AssertionError e) {
109
            Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i], "at index #" + i + ", input = " + a[i] + ", mask = " + mask[i % SPECIES.length()]);
110
        }
111
    }
112

113
    interface FReductionOp {
114
        int apply(int[] a, int idx);
115
    }
116

117
    interface FReductionAllOp {
118
        int apply(int[] a);
119
    }
120

121
    static void assertReductionArraysEquals(int[] r, int rc, int[] a,
122
                                            FReductionOp f, FReductionAllOp fa) {
123
        int i = 0;
124
        try {
125
            Assert.assertEquals(rc, fa.apply(a));
126
            for (; i < a.length; i += SPECIES.length()) {
127
                Assert.assertEquals(r[i], f.apply(a, i));
128
            }
129
        } catch (AssertionError e) {
130
            Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
131
            Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
132
        }
133
    }
134

135
    interface FReductionMaskedOp {
136
        int apply(int[] a, int idx, boolean[] mask);
137
    }
138

139
    interface FReductionAllMaskedOp {
140
        int apply(int[] a, boolean[] mask);
141
    }
142

143
    static void assertReductionArraysEqualsMasked(int[] r, int rc, int[] a, boolean[] mask,
144
                                            FReductionMaskedOp f, FReductionAllMaskedOp fa) {
145
        int i = 0;
146
        try {
147
            Assert.assertEquals(rc, fa.apply(a, mask));
148
            for (; i < a.length; i += SPECIES.length()) {
149
                Assert.assertEquals(r[i], f.apply(a, i, mask));
150
            }
151
        } catch (AssertionError e) {
152
            Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
153
            Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
154
        }
155
    }
156

157
    interface FReductionOpLong {
158
        long apply(int[] a, int idx);
159
    }
160

161
    interface FReductionAllOpLong {
162
        long apply(int[] a);
163
    }
164

165
    static void assertReductionLongArraysEquals(long[] r, long rc, int[] a,
166
                                            FReductionOpLong f, FReductionAllOpLong fa) {
167
        int i = 0;
168
        try {
169
            Assert.assertEquals(rc, fa.apply(a));
170
            for (; i < a.length; i += SPECIES.length()) {
171
                Assert.assertEquals(r[i], f.apply(a, i));
172
            }
173
        } catch (AssertionError e) {
174
            Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
175
            Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
176
        }
177
    }
178

179
    interface FReductionMaskedOpLong {
180
        long apply(int[] a, int idx, boolean[] mask);
181
    }
182

183
    interface FReductionAllMaskedOpLong {
184
        long apply(int[] a, boolean[] mask);
185
    }
186

187
    static void assertReductionLongArraysEqualsMasked(long[] r, long rc, int[] a, boolean[] mask,
188
                                            FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
189
        int i = 0;
190
        try {
191
            Assert.assertEquals(rc, fa.apply(a, mask));
192
            for (; i < a.length; i += SPECIES.length()) {
193
                Assert.assertEquals(r[i], f.apply(a, i, mask));
194
            }
195
        } catch (AssertionError e) {
196
            Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
197
            Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
198
        }
199
    }
200

201
    interface FBoolReductionOp {
202
        boolean apply(boolean[] a, int idx);
203
    }
204

205
    static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
206
        int i = 0;
207
        try {
208
            for (; i < a.length; i += SPECIES.length()) {
209
                Assert.assertEquals(r[i], f.apply(a, i));
210
            }
211
        } catch (AssertionError e) {
212
            Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
213
        }
214
    }
215

216
    static void assertInsertArraysEquals(int[] r, int[] a, int element, int index) {
217
        int i = 0;
218
        try {
219
            for (; i < a.length; i += 1) {
220
                if(i%SPECIES.length() == index) {
221
                    Assert.assertEquals(r[i], element);
222
                } else {
223
                    Assert.assertEquals(r[i], a[i]);
224
                }
225
            }
226
        } catch (AssertionError e) {
227
            if (i%SPECIES.length() == index) {
228
                Assert.assertEquals(r[i], element, "at index #" + i);
229
            } else {
230
                Assert.assertEquals(r[i], a[i], "at index #" + i);
231
            }
232
        }
233
    }
234

235
    static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, int vector_len) {
236
        int i = 0, j = 0;
237
        try {
238
            for (; i < a.length; i += vector_len) {
239
                for (j = 0; j < vector_len; j++) {
240
                    Assert.assertEquals(r[i+j], a[i+order[i+j]]);
241
                }
242
            }
243
        } catch (AssertionError e) {
244
            int idx = i + j;
245
            Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
246
        }
247
    }
248

249
    static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, int vector_len) {
250
        int i = 0, j = 0;
251
        try {
252
            for (; i < a.length; i += vector_len) {
253
                for (j = 0; j < vector_len; j++) {
254
                    Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
255
                }
256
            }
257
        } catch (AssertionError e) {
258
            int idx = i + j;
259
            Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
260
        }
261
    }
262

263
    static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) {
264
        int i = 0, j = 0;
265
        try {
266
            for (; i < a.length; i += vector_len) {
267
                for (j = 0; j < vector_len; j++) {
268
                    if (mask[j % SPECIES.length()])
269
                         Assert.assertEquals(r[i+j], a[i+order[i+j]]);
270
                    else
271
                         Assert.assertEquals(r[i+j], (int)0);
272
                }
273
            }
274
        } catch (AssertionError e) {
275
            int idx = i + j;
276
            if (mask[j % SPECIES.length()])
277
                Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
278
            else
279
                Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
280
        }
281
    }
282

283
    static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) {
284
        int i = 0, j = 0;
285
        try {
286
            for (; i < a.length; i += vector_len) {
287
                for (j = 0; j < vector_len; j++) {
288
                    if (mask[j % SPECIES.length()])
289
                         Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
290
                    else
291
                         Assert.assertEquals(r[i+j], (int)0);
292
                }
293
            }
294
        } catch (AssertionError e) {
295
            int idx = i + j;
296
            if (mask[j % SPECIES.length()])
297
                Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
298
            else
299
                Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
300
        }
301
    }
302

303
    static void assertBroadcastArraysEquals(int[] r, int[] a) {
304
        int i = 0;
305
        for (; i < a.length; i += SPECIES.length()) {
306
            int idx = i;
307
            for (int j = idx; j < (idx + SPECIES.length()); j++)
308
                a[j]=a[idx];
309
        }
310

311
        try {
312
            for (i = 0; i < a.length; i++) {
313
                Assert.assertEquals(r[i], a[i]);
314
            }
315
        } catch (AssertionError e) {
316
            Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
317
        }
318
    }
319

320
    interface FBinOp {
321
        int apply(int a, int b);
322
    }
323

324
    interface FBinMaskOp {
325
        int apply(int a, int b, boolean m);
326

327
        static FBinMaskOp lift(FBinOp f) {
328
            return (a, b, m) -> m ? f.apply(a, b) : a;
329
        }
330
    }
331

332
    static void assertArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
333
        int i = 0;
334
        try {
335
            for (; i < a.length; i++) {
336
                Assert.assertEquals(r[i], f.apply(a[i], b[i]));
337
            }
338
        } catch (AssertionError e) {
339
            Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
340
        }
341
    }
342

343
    static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
344
        int i = 0;
345
        try {
346
            for (; i < a.length; i++) {
347
                Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
348
            }
349
        } catch (AssertionError e) {
350
            Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
351
                                "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
352
        }
353
    }
354

355
    static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
356
        int i = 0;
357
        try {
358
            for (; i < a.length; i++) {
359
                Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
360
            }
361
        } catch (AssertionError e) {
362
            Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
363
                                "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
364
        }
365
    }
366

367
    static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
368
        assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
369
    }
370

371
    static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
372
        int i = 0;
373
        try {
374
            for (; i < a.length; i++) {
375
                Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
376
            }
377
        } catch (AssertionError err) {
378
            Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]);
379
        }
380
    }
381

382
    static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
383
        assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
384
    }
385

386
    static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
387
        int i = 0;
388
        try {
389
            for (; i < a.length; i++) {
390
                Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
391
            }
392
        } catch (AssertionError err) {
393
            Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
394
                                mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
395
                                ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
396
                                mask[i % SPECIES.length()]);
397
        }
398
    }
399

400
    static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
401
        assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
402
    }
403

404
    static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
405
        int i = 0;
406
        try {
407
            for (; i < a.length; i++) {
408
                Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
409
            }
410
        } catch (AssertionError err) {
411
            Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
412
                                mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
413
                                ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
414
                                mask[i % SPECIES.length()]);
415
        }
416
    }
417

418
    static void assertShiftArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
419
        int i = 0;
420
        int j = 0;
421
        try {
422
            for (; j < a.length; j += SPECIES.length()) {
423
                for (i = 0; i < SPECIES.length(); i++) {
424
                    Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
425
                }
426
            }
427
        } catch (AssertionError e) {
428
            Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
429
        }
430
    }
431

432
    static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
433
        assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
434
    }
435

436
    static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
437
        int i = 0;
438
        int j = 0;
439
        try {
440
            for (; j < a.length; j += SPECIES.length()) {
441
                for (i = 0; i < SPECIES.length(); i++) {
442
                    Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
443
                }
444
            }
445
        } catch (AssertionError err) {
446
            Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", input2 = " + b[j] + ", mask = " + mask[i]);
447
        }
448
    }
449

450
    interface FTernOp {
451
        int apply(int a, int b, int c);
452
    }
453

454
    interface FTernMaskOp {
455
        int apply(int a, int b, int c, boolean m);
456

457
        static FTernMaskOp lift(FTernOp f) {
458
            return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
459
        }
460
    }
461

462
    static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
463
        int i = 0;
464
        try {
465
            for (; i < a.length; i++) {
466
                Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
467
            }
468
        } catch (AssertionError e) {
469
            Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
470
        }
471
    }
472

473
    static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernOp f) {
474
        assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
475
    }
476

477
    static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernMaskOp f) {
478
        int i = 0;
479
        try {
480
            for (; i < a.length; i++) {
481
                Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
482
            }
483
        } catch (AssertionError err) {
484
            Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
485
              + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
486
        }
487
    }
488

489
    static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
490
        int i = 0;
491
        try {
492
            for (; i < a.length; i++) {
493
                Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
494
            }
495
        } catch (AssertionError e) {
496
            Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
497
                                i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
498
                                c[(i / SPECIES.length()) * SPECIES.length()]);
499
        }
500
    }
501

502
    static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
503
        int i = 0;
504
        try {
505
            for (; i < a.length; i++) {
506
                Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
507
            }
508
        } catch (AssertionError e) {
509
            Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
510
                                i + ", input1 = " + a[i] + ", input2 = " +
511
                                b[(i / SPECIES.length()) * SPECIES.length()] + ",  input3 = " + c[i]);
512
        }
513
    }
514

515
    static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
516
                                            FTernOp f) {
517
        assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
518
    }
519

520
    static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
521
                                            FTernMaskOp f) {
522
        int i = 0;
523
        try {
524
            for (; i < a.length; i++) {
525
                Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
526
                                    mask[i % SPECIES.length()]));
527
            }
528
        } catch (AssertionError err) {
529
            Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
530
                                mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
531
                                b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
532
                                mask[i % SPECIES.length()]);
533
        }
534
    }
535

536
    static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
537
                                            FTernOp f) {
538
        assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
539
    }
540

541
    static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
542
                                            FTernMaskOp f) {
543
        int i = 0;
544
        try {
545
            for (; i < a.length; i++) {
546
                Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
547
                                    mask[i % SPECIES.length()]));
548
            }
549
        } catch (AssertionError err) {
550
            Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
551
                                mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
552
                                ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
553
                                ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
554
        }
555
    }
556

557
    static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
558
        int i = 0;
559
        try {
560
            for (; i < a.length; i++) {
561
                Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
562
                                    c[(i / SPECIES.length()) * SPECIES.length()]));
563
            }
564
        } catch (AssertionError e) {
565
            Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
566
                                c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
567
                                + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
568
                                c[(i / SPECIES.length()) * SPECIES.length()]);
569
        }
570
    }
571

572
    static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
573
                                                  FTernOp f) {
574
        assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
575
    }
576

577
    static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
578
                                                  FTernMaskOp f) {
579
        int i = 0;
580
        try {
581
            for (; i < a.length; i++) {
582
                Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
583
                                    c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
584
            }
585
        } catch (AssertionError err) {
586
            Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
587
                                c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
588
                                + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
589
                                ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
590
                                mask[i % SPECIES.length()]);
591
        }
592
    }
593

594

595

596
    interface FBinArrayOp {
597
        int apply(int[] a, int b);
598
    }
599

600
    static void assertArraysEquals(int[] r, int[] a, FBinArrayOp f) {
601
        int i = 0;
602
        try {
603
            for (; i < a.length; i++) {
604
                Assert.assertEquals(r[i], f.apply(a, i));
605
            }
606
        } catch (AssertionError e) {
607
            Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
608
        }
609
    }
610

611
    interface FGatherScatterOp {
612
        int[] apply(int[] a, int ix, int[] b, int iy);
613
    }
614

615
    static void assertArraysEquals(int[] r, int[] a, int[] b, FGatherScatterOp f) {
616
        int i = 0;
617
        try {
618
            for (; i < a.length; i += SPECIES.length()) {
619
                Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
620
                  f.apply(a, i, b, i));
621
            }
622
        } catch (AssertionError e) {
623
            int[] ref = f.apply(a, i, b, i);
624
            int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
625
            Assert.assertEquals(res, ref,
626
              "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
627
              + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
628
              + ", b: "
629
              + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
630
              + " at index #" + i);
631
        }
632
    }
633

634
    interface FGatherMaskedOp {
635
        int[] apply(int[] a, int ix, boolean[] mask, int[] b, int iy);
636
    }
637

638
    interface FScatterMaskedOp {
639
        int[] apply(int[] r, int[] a, int ix, boolean[] mask, int[] b, int iy);
640
    }
641

642
    static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
643
        int i = 0;
644
        try {
645
            for (; i < a.length; i += SPECIES.length()) {
646
                Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
647
                  f.apply(a, i, mask, b, i));
648
            }
649
        } catch (AssertionError e) {
650
            int[] ref = f.apply(a, i, mask, b, i);
651
            int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
652
            Assert.assertEquals(res, ref,
653
              "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
654
              + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
655
              + ", b: "
656
              + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
657
              + ", mask: "
658
              + Arrays.toString(mask)
659
              + " at index #" + i);
660
        }
661
    }
662

663
    static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
664
        int i = 0;
665
        try {
666
            for (; i < a.length; i += SPECIES.length()) {
667
                Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
668
                  f.apply(r, a, i, mask, b, i));
669
            }
670
        } catch (AssertionError e) {
671
            int[] ref = f.apply(r, a, i, mask, b, i);
672
            int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
673
            Assert.assertEquals(res, ref,
674
              "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
675
              + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
676
              + ", b: "
677
              + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
678
              + ", r: "
679
              + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
680
              + ", mask: "
681
              + Arrays.toString(mask)
682
              + " at index #" + i);
683
        }
684
    }
685

686
    interface FLaneOp {
687
        int[] apply(int[] a, int origin, int idx);
688
    }
689

690
    static void assertArraysEquals(int[] r, int[] a, int origin, FLaneOp f) {
691
        int i = 0;
692
        try {
693
            for (; i < a.length; i += SPECIES.length()) {
694
                Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
695
                  f.apply(a, origin, i));
696
            }
697
        } catch (AssertionError e) {
698
            int[] ref = f.apply(a, origin, i);
699
            int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
700
            Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
701
              + ", res: " + Arrays.toString(res)
702
              + "), at index #" + i);
703
        }
704
    }
705

706
    interface FLaneBop {
707
        int[] apply(int[] a, int[] b, int origin, int idx);
708
    }
709

710
    static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, FLaneBop f) {
711
        int i = 0;
712
        try {
713
            for (; i < a.length; i += SPECIES.length()) {
714
                Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
715
                  f.apply(a, b, origin, i));
716
            }
717
        } catch (AssertionError e) {
718
            int[] ref = f.apply(a, b, origin, i);
719
            int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
720
            Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
721
              + ", res: " + Arrays.toString(res)
722
              + "), at index #" + i
723
              + ", at origin #" + origin);
724
        }
725
    }
726

727
    interface FLaneMaskedBop {
728
        int[] apply(int[] a, int[] b, int origin, boolean[] mask, int idx);
729
    }
730

731
    static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
732
        int i = 0;
733
        try {
734
            for (; i < a.length; i += SPECIES.length()) {
735
                Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
736
                  f.apply(a, b, origin, mask, i));
737
            }
738
        } catch (AssertionError e) {
739
            int[] ref = f.apply(a, b, origin, mask, i);
740
            int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
741
            Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
742
              + ", res: " + Arrays.toString(res)
743
              + "), at index #" + i
744
              + ", at origin #" + origin);
745
        }
746
    }
747

748
    interface FLanePartBop {
749
        int[] apply(int[] a, int[] b, int origin, int part, int idx);
750
    }
751

752
    static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, FLanePartBop f) {
753
        int i = 0;
754
        try {
755
            for (; i < a.length; i += SPECIES.length()) {
756
                Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
757
                  f.apply(a, b, origin, part, i));
758
            }
759
        } catch (AssertionError e) {
760
            int[] ref = f.apply(a, b, origin, part, i);
761
            int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
762
            Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
763
              + ", res: " + Arrays.toString(res)
764
              + "), at index #" + i
765
              + ", at origin #" + origin
766
              + ", with part #" + part);
767
        }
768
    }
769

770
    interface FLanePartMaskedBop {
771
        int[] apply(int[] a, int[] b, int origin, int part, boolean[] mask, int idx);
772
    }
773

774
    static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
775
        int i = 0;
776
        try {
777
            for (; i < a.length; i += SPECIES.length()) {
778
                Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
779
                  f.apply(a, b, origin, part, mask, i));
780
            }
781
        } catch (AssertionError e) {
782
            int[] ref = f.apply(a, b, origin, part, mask, i);
783
            int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
784
            Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
785
              + ", res: " + Arrays.toString(res)
786
              + "), at index #" + i
787
              + ", at origin #" + origin
788
              + ", with part #" + part);
789
        }
790
    }
791

792

793
    static void assertArraysEquals(int[] r, int[] a, int offs) {
794
        int i = 0;
795
        try {
796
            for (; i < r.length; i++) {
797
                Assert.assertEquals(r[i], (int)(a[i+offs]));
798
            }
799
        } catch (AssertionError e) {
800
            Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
801
        }
802
    }
803

804

805

806
    static void assertArraysEquals(long[] r, int[] a, int offs) {
807
        int i = 0;
808
        try {
809
            for (; i < r.length; i++) {
810
                Assert.assertEquals(r[i], (long)(a[i+offs]));
811
            }
812
        } catch (AssertionError e) {
813
            Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
814
        }
815
    }
816

817
    static void assertArraysEquals(double[] r, int[] a, int offs) {
818
        int i = 0;
819
        try {
820
            for (; i < r.length; i++) {
821
                Assert.assertEquals(r[i], (double)(a[i+offs]));
822
            }
823
        } catch (AssertionError e) {
824
            Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
825
        }
826
    }
827

828

829
    static int bits(int e) {
830
        return  e;
831
    }
832

833
    static final List<IntFunction<int[]>> INT_GENERATORS = List.of(
834
            withToString("int[-i * 5]", (int s) -> {
835
                return fill(s * BUFFER_REPS,
836
                            i -> (int)(-i * 5));
837
            }),
838
            withToString("int[i * 5]", (int s) -> {
839
                return fill(s * BUFFER_REPS,
840
                            i -> (int)(i * 5));
841
            }),
842
            withToString("int[i + 1]", (int s) -> {
843
                return fill(s * BUFFER_REPS,
844
                            i -> (((int)(i + 1) == 0) ? 1 : (int)(i + 1)));
845
            }),
846
            withToString("int[cornerCaseValue(i)]", (int s) -> {
847
                return fill(s * BUFFER_REPS,
848
                            i -> cornerCaseValue(i));
849
            })
850
    );
851

852
    // Create combinations of pairs
853
    // @@@ Might be sensitive to order e.g. div by 0
854
    static final List<List<IntFunction<int[]>>> INT_GENERATOR_PAIRS =
855
        Stream.of(INT_GENERATORS.get(0)).
856
                flatMap(fa -> INT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
857
                collect(Collectors.toList());
858

859
    @DataProvider
860
    public Object[][] boolUnaryOpProvider() {
861
        return BOOL_ARRAY_GENERATORS.stream().
862
                map(f -> new Object[]{f}).
863
                toArray(Object[][]::new);
864
    }
865

866
    static final List<List<IntFunction<int[]>>> INT_GENERATOR_TRIPLES =
867
        INT_GENERATOR_PAIRS.stream().
868
                flatMap(pair -> INT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
869
                collect(Collectors.toList());
870

871
    @DataProvider
872
    public Object[][] intBinaryOpProvider() {
873
        return INT_GENERATOR_PAIRS.stream().map(List::toArray).
874
                toArray(Object[][]::new);
875
    }
876

877
    @DataProvider
878
    public Object[][] intIndexedOpProvider() {
879
        return INT_GENERATOR_PAIRS.stream().map(List::toArray).
880
                toArray(Object[][]::new);
881
    }
882

883
    @DataProvider
884
    public Object[][] intBinaryOpMaskProvider() {
885
        return BOOLEAN_MASK_GENERATORS.stream().
886
                flatMap(fm -> INT_GENERATOR_PAIRS.stream().map(lfa -> {
887
                    return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
888
                })).
889
                toArray(Object[][]::new);
890
    }
891

892
    @DataProvider
893
    public Object[][] intTernaryOpProvider() {
894
        return INT_GENERATOR_TRIPLES.stream().map(List::toArray).
895
                toArray(Object[][]::new);
896
    }
897

898
    @DataProvider
899
    public Object[][] intTernaryOpMaskProvider() {
900
        return BOOLEAN_MASK_GENERATORS.stream().
901
                flatMap(fm -> INT_GENERATOR_TRIPLES.stream().map(lfa -> {
902
                    return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
903
                })).
904
                toArray(Object[][]::new);
905
    }
906

907
    @DataProvider
908
    public Object[][] intUnaryOpProvider() {
909
        return INT_GENERATORS.stream().
910
                map(f -> new Object[]{f}).
911
                toArray(Object[][]::new);
912
    }
913

914
    @DataProvider
915
    public Object[][] intUnaryOpMaskProvider() {
916
        return BOOLEAN_MASK_GENERATORS.stream().
917
                flatMap(fm -> INT_GENERATORS.stream().map(fa -> {
918
                    return new Object[] {fa, fm};
919
                })).
920
                toArray(Object[][]::new);
921
    }
922

923

924

925
    @DataProvider
926
    public Object[][] maskProvider() {
927
        return BOOLEAN_MASK_GENERATORS.stream().
928
                map(f -> new Object[]{f}).
929
                toArray(Object[][]::new);
930
    }
931

932
    @DataProvider
933
    public Object[][] maskCompareOpProvider() {
934
        return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
935
                toArray(Object[][]::new);
936
    }
937

938
    @DataProvider
939
    public Object[][] shuffleProvider() {
940
        return INT_SHUFFLE_GENERATORS.stream().
941
                map(f -> new Object[]{f}).
942
                toArray(Object[][]::new);
943
    }
944

945
    @DataProvider
946
    public Object[][] shuffleCompareOpProvider() {
947
        return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
948
                toArray(Object[][]::new);
949
    }
950

951
    @DataProvider
952
    public Object[][] intUnaryOpShuffleProvider() {
953
        return INT_SHUFFLE_GENERATORS.stream().
954
                flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
955
                    return new Object[] {fa, fs};
956
                })).
957
                toArray(Object[][]::new);
958
    }
959

960
    @DataProvider
961
    public Object[][] intUnaryOpShuffleMaskProvider() {
962
        return BOOLEAN_MASK_GENERATORS.stream().
963
                flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
964
                    flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
965
                        return new Object[] {fa, fs, fm};
966
                }))).
967
                toArray(Object[][]::new);
968
    }
969

970

971
    @DataProvider
972
    public Object[][] intUnaryOpIndexProvider() {
973
        return INT_INDEX_GENERATORS.stream().
974
                flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
975
                    return new Object[] {fa, fs};
976
                })).
977
                toArray(Object[][]::new);
978
    }
979

980
    @DataProvider
981
    public Object[][] intUnaryMaskedOpIndexProvider() {
982
        return BOOLEAN_MASK_GENERATORS.stream().
983
          flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
984
            INT_GENERATORS.stream().map(fa -> {
985
                    return new Object[] {fa, fm, fs};
986
            }))).
987
            toArray(Object[][]::new);
988
    }
989

990
    @DataProvider
991
    public Object[][] scatterMaskedOpIndexProvider() {
992
        return BOOLEAN_MASK_GENERATORS.stream().
993
          flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
994
            INT_GENERATORS.stream().flatMap(fn ->
995
              INT_GENERATORS.stream().map(fa -> {
996
                    return new Object[] {fa, fn, fm, fs};
997
            })))).
998
            toArray(Object[][]::new);
999
    }
1000

1001
    static final List<IntFunction<int[]>> INT_COMPARE_GENERATORS = List.of(
1002
            withToString("int[i]", (int s) -> {
1003
                return fill(s * BUFFER_REPS,
1004
                            i -> (int)i);
1005
            }),
1006
            withToString("int[i - length / 2]", (int s) -> {
1007
                return fill(s * BUFFER_REPS,
1008
                            i -> (int)(i - (s * BUFFER_REPS / 2)));
1009
            }),
1010
            withToString("int[i + 1]", (int s) -> {
1011
                return fill(s * BUFFER_REPS,
1012
                            i -> (int)(i + 1));
1013
            }),
1014
            withToString("int[i - 2]", (int s) -> {
1015
                return fill(s * BUFFER_REPS,
1016
                            i -> (int)(i - 2));
1017
            }),
1018
            withToString("int[zigZag(i)]", (int s) -> {
1019
                return fill(s * BUFFER_REPS,
1020
                            i -> i%3 == 0 ? (int)i : (i%3 == 1 ? (int)(i + 1) : (int)(i - 2)));
1021
            }),
1022
            withToString("int[cornerCaseValue(i)]", (int s) -> {
1023
                return fill(s * BUFFER_REPS,
1024
                            i -> cornerCaseValue(i));
1025
            })
1026
    );
1027

1028
    static final List<List<IntFunction<int[]>>> INT_TEST_GENERATOR_ARGS =
1029
        INT_COMPARE_GENERATORS.stream().
1030
                map(fa -> List.of(fa)).
1031
                collect(Collectors.toList());
1032

1033
    @DataProvider
1034
    public Object[][] intTestOpProvider() {
1035
        return INT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1036
                toArray(Object[][]::new);
1037
    }
1038

1039
    @DataProvider
1040
    public Object[][] intTestOpMaskProvider() {
1041
        return BOOLEAN_MASK_GENERATORS.stream().
1042
                flatMap(fm -> INT_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1043
                    return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1044
                })).
1045
                toArray(Object[][]::new);
1046
    }
1047

1048
    static final List<List<IntFunction<int[]>>> INT_COMPARE_GENERATOR_PAIRS =
1049
        INT_COMPARE_GENERATORS.stream().
1050
                flatMap(fa -> INT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1051
                collect(Collectors.toList());
1052

1053
    @DataProvider
1054
    public Object[][] intCompareOpProvider() {
1055
        return INT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1056
                toArray(Object[][]::new);
1057
    }
1058

1059
    @DataProvider
1060
    public Object[][] intCompareOpMaskProvider() {
1061
        return BOOLEAN_MASK_GENERATORS.stream().
1062
                flatMap(fm -> INT_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1063
                    return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1064
                })).
1065
                toArray(Object[][]::new);
1066
    }
1067

1068
    interface ToIntF {
1069
        int apply(int i);
1070
    }
1071

1072
    static int[] fill(int s , ToIntF f) {
1073
        return fill(new int[s], f);
1074
    }
1075

1076
    static int[] fill(int[] a, ToIntF f) {
1077
        for (int i = 0; i < a.length; i++) {
1078
            a[i] = f.apply(i);
1079
        }
1080
        return a;
1081
    }
1082

1083
    static int cornerCaseValue(int i) {
1084
        switch(i % 5) {
1085
            case 0:
1086
                return Integer.MAX_VALUE;
1087
            case 1:
1088
                return Integer.MIN_VALUE;
1089
            case 2:
1090
                return Integer.MIN_VALUE;
1091
            case 3:
1092
                return Integer.MAX_VALUE;
1093
            default:
1094
                return (int)0;
1095
        }
1096
    }
1097

1098
    static int get(int[] a, int i) {
1099
        return (int) a[i];
1100
    }
1101

1102
    static final IntFunction<int[]> fr = (vl) -> {
1103
        int length = BUFFER_REPS * vl;
1104
        return new int[length];
1105
    };
1106

1107
    static final IntFunction<boolean[]> fmr = (vl) -> {
1108
        int length = BUFFER_REPS * vl;
1109
        return new boolean[length];
1110
    };
1111

1112
    static final IntFunction<long[]> lfr = (vl) -> {
1113
        int length = BUFFER_REPS * vl;
1114
        return new long[length];
1115
    };
1116

1117
    static void replaceZero(int[] a, int v) {
1118
        for (int i = 0; i < a.length; i++) {
1119
            if (a[i] == 0) {
1120
                a[i] = v;
1121
            }
1122
        }
1123
    }
1124

1125
    static void replaceZero(int[] a, boolean[] mask, int v) {
1126
        for (int i = 0; i < a.length; i++) {
1127
            if (mask[i % mask.length] && a[i] == 0) {
1128
                a[i] = v;
1129
            }
1130
        }
1131
    }
1132

1133
    static boolean eq(int a, int b) {
1134
        return a == b;
1135
    }
1136

1137
    static boolean neq(int a, int b) {
1138
        return a != b;
1139
    }
1140

1141
    static boolean lt(int a, int b) {
1142
        return a < b;
1143
    }
1144

1145
    static boolean le(int a, int b) {
1146
        return a <= b;
1147
    }
1148

1149
    static boolean gt(int a, int b) {
1150
        return a > b;
1151
    }
1152

1153
    static boolean ge(int a, int b) {
1154
        return a >= b;
1155
    }
1156

1157
    static boolean ult(int a, int b) {
1158
        return Integer.compareUnsigned(a, b) < 0;
1159
    }
1160

1161
    static boolean ule(int a, int b) {
1162
        return Integer.compareUnsigned(a, b) <= 0;
1163
    }
1164

1165
    static boolean ugt(int a, int b) {
1166
        return Integer.compareUnsigned(a, b) > 0;
1167
    }
1168

1169
    static boolean uge(int a, int b) {
1170
        return Integer.compareUnsigned(a, b) >= 0;
1171
    }
1172

1173
    @Test
1174
    static void smokeTest1() {
1175
        IntVector three = IntVector.broadcast(SPECIES, (byte)-3);
1176
        IntVector three2 = (IntVector) SPECIES.broadcast(-3);
1177
        assert(three.eq(three2).allTrue());
1178
        IntVector three3 = three2.broadcast(1).broadcast(-3);
1179
        assert(three.eq(three3).allTrue());
1180
        int scale = 2;
1181
        Class<?> ETYPE = int.class;
1182
        if (ETYPE == double.class || ETYPE == long.class)
1183
            scale = 1000000;
1184
        else if (ETYPE == byte.class && SPECIES.length() >= 64)
1185
            scale = 1;
1186
        IntVector higher = three.addIndex(scale);
1187
        VectorMask<Integer> m = three.compare(VectorOperators.LE, higher);
1188
        assert(m.allTrue());
1189
        m = higher.min((int)-1).test(VectorOperators.IS_NEGATIVE);
1190
        assert(m.allTrue());
1191
        int max = higher.reduceLanes(VectorOperators.MAX);
1192
        assert(max == -3 + scale * (SPECIES.length()-1));
1193
    }
1194

1195
    private static int[]
1196
    bothToArray(IntVector a, IntVector b) {
1197
        int[] r = new int[a.length() + b.length()];
1198
        a.intoArray(r, 0);
1199
        b.intoArray(r, a.length());
1200
        return r;
1201
    }
1202

1203
    @Test
1204
    static void smokeTest2() {
1205
        // Do some zipping and shuffling.
1206
        IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
1207
        IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1208
        Assert.assertEquals(io, io2);
1209
        IntVector a = io.add((int)1); //[1,2]
1210
        IntVector b = a.neg();  //[-1,-2]
1211
        int[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1212
        VectorShuffle<Integer> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1213
        VectorShuffle<Integer> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1214
        IntVector zab0 = a.rearrange(zip0,b); //[1,-1]
1215
        IntVector zab1 = a.rearrange(zip1,b); //[2,-2]
1216
        int[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1217
        // manually zip
1218
        int[] manual = new int[zabValues.length];
1219
        for (int i = 0; i < manual.length; i += 2) {
1220
            manual[i+0] = abValues[i/2];
1221
            manual[i+1] = abValues[a.length() + i/2];
1222
        }
1223
        Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1224
        VectorShuffle<Integer> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1225
        VectorShuffle<Integer> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1226
        IntVector uab0 = zab0.rearrange(unz0,zab1);
1227
        IntVector uab1 = zab0.rearrange(unz1,zab1);
1228
        int[] abValues1 = bothToArray(uab0, uab1);
1229
        Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1230
    }
1231

1232
    static void iotaShuffle() {
1233
        IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
1234
        IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1235
        Assert.assertEquals(io, io2);
1236
    }
1237

1238
    @Test
1239
    // Test all shuffle related operations.
1240
    static void shuffleTest() {
1241
        // To test backend instructions, make sure that C2 is used.
1242
        for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1243
            iotaShuffle();
1244
        }
1245
    }
1246

1247
    @Test
1248
    void viewAsIntegeralLanesTest() {
1249
        Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1250
        Assert.assertEquals(asIntegral.species(), SPECIES);
1251
    }
1252

1253
    @Test
1254
    void viewAsFloatingLanesTest() {
1255
        Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
1256
        VectorSpecies<?> asFloatingSpecies = asFloating.species();
1257
        Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
1258
        Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
1259
        Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
1260
        Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
1261
    }
1262

1263
    @Test
1264
    // Test div by 0.
1265
    static void bitwiseDivByZeroSmokeTest() {
1266
        try {
1267
            IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
1268
            IntVector b = (IntVector) SPECIES.broadcast(0);
1269
            a.div(b);
1270
            Assert.fail();
1271
        } catch (ArithmeticException e) {
1272
        }
1273

1274
        try {
1275
            IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
1276
            IntVector b = (IntVector) SPECIES.broadcast(0);
1277
            VectorMask<Integer> m = a.lt((int) 1);
1278
            a.div(b, m);
1279
            Assert.fail();
1280
        } catch (ArithmeticException e) {
1281
        }
1282
    }
1283
    static int ADD(int a, int b) {
1284
        return (int)(a + b);
1285
    }
1286

1287
    @Test(dataProvider = "intBinaryOpProvider")
1288
    static void ADDInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1289
        int[] a = fa.apply(SPECIES.length());
1290
        int[] b = fb.apply(SPECIES.length());
1291
        int[] r = fr.apply(SPECIES.length());
1292

1293
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1294
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1295
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1296
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1297
                av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1298
            }
1299
        }
1300

1301
        assertArraysEquals(r, a, b, Int128VectorTests::ADD);
1302
    }
1303
    static int add(int a, int b) {
1304
        return (int)(a + b);
1305
    }
1306

1307
    @Test(dataProvider = "intBinaryOpProvider")
1308
    static void addInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1309
        int[] a = fa.apply(SPECIES.length());
1310
        int[] b = fb.apply(SPECIES.length());
1311
        int[] r = fr.apply(SPECIES.length());
1312

1313
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1314
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1315
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
1316
            av.add(bv).intoArray(r, i);
1317
        }
1318

1319
        assertArraysEquals(r, a, b, Int128VectorTests::add);
1320
    }
1321

1322
    @Test(dataProvider = "intBinaryOpMaskProvider")
1323
    static void ADDInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1324
                                          IntFunction<boolean[]> fm) {
1325
        int[] a = fa.apply(SPECIES.length());
1326
        int[] b = fb.apply(SPECIES.length());
1327
        int[] r = fr.apply(SPECIES.length());
1328
        boolean[] mask = fm.apply(SPECIES.length());
1329
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1330

1331
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1332
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1333
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1334
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1335
                av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1336
            }
1337
        }
1338

1339
        assertArraysEquals(r, a, b, mask, Int128VectorTests::ADD);
1340
    }
1341

1342
    @Test(dataProvider = "intBinaryOpMaskProvider")
1343
    static void addInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1344
                                          IntFunction<boolean[]> fm) {
1345
        int[] a = fa.apply(SPECIES.length());
1346
        int[] b = fb.apply(SPECIES.length());
1347
        int[] r = fr.apply(SPECIES.length());
1348
        boolean[] mask = fm.apply(SPECIES.length());
1349
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1350

1351
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1352
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1353
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
1354
            av.add(bv, vmask).intoArray(r, i);
1355
        }
1356

1357
        assertArraysEquals(r, a, b, mask, Int128VectorTests::add);
1358
    }
1359
    static int SUB(int a, int b) {
1360
        return (int)(a - b);
1361
    }
1362

1363
    @Test(dataProvider = "intBinaryOpProvider")
1364
    static void SUBInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1365
        int[] a = fa.apply(SPECIES.length());
1366
        int[] b = fb.apply(SPECIES.length());
1367
        int[] r = fr.apply(SPECIES.length());
1368

1369
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1370
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1371
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1372
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1373
                av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1374
            }
1375
        }
1376

1377
        assertArraysEquals(r, a, b, Int128VectorTests::SUB);
1378
    }
1379
    static int sub(int a, int b) {
1380
        return (int)(a - b);
1381
    }
1382

1383
    @Test(dataProvider = "intBinaryOpProvider")
1384
    static void subInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1385
        int[] a = fa.apply(SPECIES.length());
1386
        int[] b = fb.apply(SPECIES.length());
1387
        int[] r = fr.apply(SPECIES.length());
1388

1389
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1390
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1391
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
1392
            av.sub(bv).intoArray(r, i);
1393
        }
1394

1395
        assertArraysEquals(r, a, b, Int128VectorTests::sub);
1396
    }
1397

1398
    @Test(dataProvider = "intBinaryOpMaskProvider")
1399
    static void SUBInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1400
                                          IntFunction<boolean[]> fm) {
1401
        int[] a = fa.apply(SPECIES.length());
1402
        int[] b = fb.apply(SPECIES.length());
1403
        int[] r = fr.apply(SPECIES.length());
1404
        boolean[] mask = fm.apply(SPECIES.length());
1405
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1406

1407
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1408
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1409
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1410
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1411
                av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1412
            }
1413
        }
1414

1415
        assertArraysEquals(r, a, b, mask, Int128VectorTests::SUB);
1416
    }
1417

1418
    @Test(dataProvider = "intBinaryOpMaskProvider")
1419
    static void subInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1420
                                          IntFunction<boolean[]> fm) {
1421
        int[] a = fa.apply(SPECIES.length());
1422
        int[] b = fb.apply(SPECIES.length());
1423
        int[] r = fr.apply(SPECIES.length());
1424
        boolean[] mask = fm.apply(SPECIES.length());
1425
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1426

1427
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1428
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1429
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
1430
            av.sub(bv, vmask).intoArray(r, i);
1431
        }
1432

1433
        assertArraysEquals(r, a, b, mask, Int128VectorTests::sub);
1434
    }
1435
    static int MUL(int a, int b) {
1436
        return (int)(a * b);
1437
    }
1438

1439
    @Test(dataProvider = "intBinaryOpProvider")
1440
    static void MULInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1441
        int[] a = fa.apply(SPECIES.length());
1442
        int[] b = fb.apply(SPECIES.length());
1443
        int[] r = fr.apply(SPECIES.length());
1444

1445
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1446
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1447
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1448
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1449
                av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1450
            }
1451
        }
1452

1453
        assertArraysEquals(r, a, b, Int128VectorTests::MUL);
1454
    }
1455
    static int mul(int a, int b) {
1456
        return (int)(a * b);
1457
    }
1458

1459
    @Test(dataProvider = "intBinaryOpProvider")
1460
    static void mulInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1461
        int[] a = fa.apply(SPECIES.length());
1462
        int[] b = fb.apply(SPECIES.length());
1463
        int[] r = fr.apply(SPECIES.length());
1464

1465
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1466
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1467
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
1468
            av.mul(bv).intoArray(r, i);
1469
        }
1470

1471
        assertArraysEquals(r, a, b, Int128VectorTests::mul);
1472
    }
1473

1474
    @Test(dataProvider = "intBinaryOpMaskProvider")
1475
    static void MULInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1476
                                          IntFunction<boolean[]> fm) {
1477
        int[] a = fa.apply(SPECIES.length());
1478
        int[] b = fb.apply(SPECIES.length());
1479
        int[] r = fr.apply(SPECIES.length());
1480
        boolean[] mask = fm.apply(SPECIES.length());
1481
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1482

1483
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1484
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1485
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1486
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1487
                av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1488
            }
1489
        }
1490

1491
        assertArraysEquals(r, a, b, mask, Int128VectorTests::MUL);
1492
    }
1493

1494
    @Test(dataProvider = "intBinaryOpMaskProvider")
1495
    static void mulInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1496
                                          IntFunction<boolean[]> fm) {
1497
        int[] a = fa.apply(SPECIES.length());
1498
        int[] b = fb.apply(SPECIES.length());
1499
        int[] r = fr.apply(SPECIES.length());
1500
        boolean[] mask = fm.apply(SPECIES.length());
1501
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1502

1503
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1504
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1505
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
1506
            av.mul(bv, vmask).intoArray(r, i);
1507
        }
1508

1509
        assertArraysEquals(r, a, b, mask, Int128VectorTests::mul);
1510
    }
1511

1512

1513

1514
    static int DIV(int a, int b) {
1515
        return (int)(a / b);
1516
    }
1517

1518
    @Test(dataProvider = "intBinaryOpProvider")
1519
    static void DIVInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1520
        int[] a = fa.apply(SPECIES.length());
1521
        int[] b = fb.apply(SPECIES.length());
1522
        int[] r = fr.apply(SPECIES.length());
1523

1524
        replaceZero(b, (int) 1);
1525

1526
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1527
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1528
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1529
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1530
                av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1531
            }
1532
        }
1533

1534
        assertArraysEquals(r, a, b, Int128VectorTests::DIV);
1535
    }
1536
    static int div(int a, int b) {
1537
        return (int)(a / b);
1538
    }
1539

1540
    @Test(dataProvider = "intBinaryOpProvider")
1541
    static void divInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1542
        int[] a = fa.apply(SPECIES.length());
1543
        int[] b = fb.apply(SPECIES.length());
1544
        int[] r = fr.apply(SPECIES.length());
1545

1546
        replaceZero(b, (int) 1);
1547

1548
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1549
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1550
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1551
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1552
                av.div(bv).intoArray(r, i);
1553
            }
1554
        }
1555

1556
        assertArraysEquals(r, a, b, Int128VectorTests::div);
1557
    }
1558

1559

1560

1561
    @Test(dataProvider = "intBinaryOpMaskProvider")
1562
    static void DIVInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1563
                                          IntFunction<boolean[]> fm) {
1564
        int[] a = fa.apply(SPECIES.length());
1565
        int[] b = fb.apply(SPECIES.length());
1566
        int[] r = fr.apply(SPECIES.length());
1567
        boolean[] mask = fm.apply(SPECIES.length());
1568
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1569

1570
        replaceZero(b, mask, (int) 1);
1571

1572
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1573
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1574
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1575
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1576
                av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1577
            }
1578
        }
1579

1580
        assertArraysEquals(r, a, b, mask, Int128VectorTests::DIV);
1581
    }
1582

1583
    @Test(dataProvider = "intBinaryOpMaskProvider")
1584
    static void divInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1585
                                          IntFunction<boolean[]> fm) {
1586
        int[] a = fa.apply(SPECIES.length());
1587
        int[] b = fb.apply(SPECIES.length());
1588
        int[] r = fr.apply(SPECIES.length());
1589
        boolean[] mask = fm.apply(SPECIES.length());
1590
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1591

1592
        replaceZero(b, mask, (int) 1);
1593

1594
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1595
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1596
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1597
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1598
                av.div(bv, vmask).intoArray(r, i);
1599
            }
1600
        }
1601

1602
        assertArraysEquals(r, a, b, mask, Int128VectorTests::div);
1603
    }
1604

1605
    static int FIRST_NONZERO(int a, int b) {
1606
        return (int)((a)!=0?a:b);
1607
    }
1608

1609
    @Test(dataProvider = "intBinaryOpProvider")
1610
    static void FIRST_NONZEROInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1611
        int[] a = fa.apply(SPECIES.length());
1612
        int[] b = fb.apply(SPECIES.length());
1613
        int[] r = fr.apply(SPECIES.length());
1614

1615
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1616
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1617
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1618
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1619
                av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1620
            }
1621
        }
1622

1623
        assertArraysEquals(r, a, b, Int128VectorTests::FIRST_NONZERO);
1624
    }
1625

1626
    @Test(dataProvider = "intBinaryOpMaskProvider")
1627
    static void FIRST_NONZEROInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1628
                                          IntFunction<boolean[]> fm) {
1629
        int[] a = fa.apply(SPECIES.length());
1630
        int[] b = fb.apply(SPECIES.length());
1631
        int[] r = fr.apply(SPECIES.length());
1632
        boolean[] mask = fm.apply(SPECIES.length());
1633
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1634

1635
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1636
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1637
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1638
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1639
                av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1640
            }
1641
        }
1642

1643
        assertArraysEquals(r, a, b, mask, Int128VectorTests::FIRST_NONZERO);
1644
    }
1645

1646
    static int AND(int a, int b) {
1647
        return (int)(a & b);
1648
    }
1649

1650
    @Test(dataProvider = "intBinaryOpProvider")
1651
    static void ANDInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1652
        int[] a = fa.apply(SPECIES.length());
1653
        int[] b = fb.apply(SPECIES.length());
1654
        int[] r = fr.apply(SPECIES.length());
1655

1656
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1657
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1658
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1659
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1660
                av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1661
            }
1662
        }
1663

1664
        assertArraysEquals(r, a, b, Int128VectorTests::AND);
1665
    }
1666
    static int and(int a, int b) {
1667
        return (int)(a & b);
1668
    }
1669

1670
    @Test(dataProvider = "intBinaryOpProvider")
1671
    static void andInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1672
        int[] a = fa.apply(SPECIES.length());
1673
        int[] b = fb.apply(SPECIES.length());
1674
        int[] r = fr.apply(SPECIES.length());
1675

1676
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1677
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1678
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
1679
            av.and(bv).intoArray(r, i);
1680
        }
1681

1682
        assertArraysEquals(r, a, b, Int128VectorTests::and);
1683
    }
1684

1685

1686

1687
    @Test(dataProvider = "intBinaryOpMaskProvider")
1688
    static void ANDInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1689
                                          IntFunction<boolean[]> fm) {
1690
        int[] a = fa.apply(SPECIES.length());
1691
        int[] b = fb.apply(SPECIES.length());
1692
        int[] r = fr.apply(SPECIES.length());
1693
        boolean[] mask = fm.apply(SPECIES.length());
1694
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1695

1696
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1697
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1698
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1699
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1700
                av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1701
            }
1702
        }
1703

1704
        assertArraysEquals(r, a, b, mask, Int128VectorTests::AND);
1705
    }
1706

1707

1708
    static int AND_NOT(int a, int b) {
1709
        return (int)(a & ~b);
1710
    }
1711

1712
    @Test(dataProvider = "intBinaryOpProvider")
1713
    static void AND_NOTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1714
        int[] a = fa.apply(SPECIES.length());
1715
        int[] b = fb.apply(SPECIES.length());
1716
        int[] r = fr.apply(SPECIES.length());
1717

1718
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1719
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1720
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1721
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1722
                av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
1723
            }
1724
        }
1725

1726
        assertArraysEquals(r, a, b, Int128VectorTests::AND_NOT);
1727
    }
1728

1729

1730

1731
    @Test(dataProvider = "intBinaryOpMaskProvider")
1732
    static void AND_NOTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1733
                                          IntFunction<boolean[]> fm) {
1734
        int[] a = fa.apply(SPECIES.length());
1735
        int[] b = fb.apply(SPECIES.length());
1736
        int[] r = fr.apply(SPECIES.length());
1737
        boolean[] mask = fm.apply(SPECIES.length());
1738
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1739

1740
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1741
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1742
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1743
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1744
                av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
1745
            }
1746
        }
1747

1748
        assertArraysEquals(r, a, b, mask, Int128VectorTests::AND_NOT);
1749
    }
1750

1751

1752
    static int OR(int a, int b) {
1753
        return (int)(a | b);
1754
    }
1755

1756
    @Test(dataProvider = "intBinaryOpProvider")
1757
    static void ORInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1758
        int[] a = fa.apply(SPECIES.length());
1759
        int[] b = fb.apply(SPECIES.length());
1760
        int[] r = fr.apply(SPECIES.length());
1761

1762
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1763
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1764
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1765
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1766
                av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1767
            }
1768
        }
1769

1770
        assertArraysEquals(r, a, b, Int128VectorTests::OR);
1771
    }
1772
    static int or(int a, int b) {
1773
        return (int)(a | b);
1774
    }
1775

1776
    @Test(dataProvider = "intBinaryOpProvider")
1777
    static void orInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1778
        int[] a = fa.apply(SPECIES.length());
1779
        int[] b = fb.apply(SPECIES.length());
1780
        int[] r = fr.apply(SPECIES.length());
1781

1782
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1783
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1784
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
1785
            av.or(bv).intoArray(r, i);
1786
        }
1787

1788
        assertArraysEquals(r, a, b, Int128VectorTests::or);
1789
    }
1790

1791

1792

1793
    @Test(dataProvider = "intBinaryOpMaskProvider")
1794
    static void ORInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1795
                                          IntFunction<boolean[]> fm) {
1796
        int[] a = fa.apply(SPECIES.length());
1797
        int[] b = fb.apply(SPECIES.length());
1798
        int[] r = fr.apply(SPECIES.length());
1799
        boolean[] mask = fm.apply(SPECIES.length());
1800
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1801

1802
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1803
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1804
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1805
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1806
                av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1807
            }
1808
        }
1809

1810
        assertArraysEquals(r, a, b, mask, Int128VectorTests::OR);
1811
    }
1812

1813

1814
    static int XOR(int a, int b) {
1815
        return (int)(a ^ b);
1816
    }
1817

1818
    @Test(dataProvider = "intBinaryOpProvider")
1819
    static void XORInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1820
        int[] a = fa.apply(SPECIES.length());
1821
        int[] b = fb.apply(SPECIES.length());
1822
        int[] r = fr.apply(SPECIES.length());
1823

1824
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1825
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1826
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1827
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1828
                av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
1829
            }
1830
        }
1831

1832
        assertArraysEquals(r, a, b, Int128VectorTests::XOR);
1833
    }
1834

1835

1836

1837
    @Test(dataProvider = "intBinaryOpMaskProvider")
1838
    static void XORInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1839
                                          IntFunction<boolean[]> fm) {
1840
        int[] a = fa.apply(SPECIES.length());
1841
        int[] b = fb.apply(SPECIES.length());
1842
        int[] r = fr.apply(SPECIES.length());
1843
        boolean[] mask = fm.apply(SPECIES.length());
1844
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1845

1846
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
1847
            for (int i = 0; i < a.length; i += SPECIES.length()) {
1848
                IntVector av = IntVector.fromArray(SPECIES, a, i);
1849
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
1850
                av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1851
            }
1852
        }
1853

1854
        assertArraysEquals(r, a, b, mask, Int128VectorTests::XOR);
1855
    }
1856

1857

1858
    @Test(dataProvider = "intBinaryOpProvider")
1859
    static void addInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1860
        int[] a = fa.apply(SPECIES.length());
1861
        int[] b = fb.apply(SPECIES.length());
1862
        int[] r = fr.apply(SPECIES.length());
1863

1864
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1865
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1866
            av.add(b[i]).intoArray(r, i);
1867
        }
1868

1869
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::add);
1870
    }
1871

1872
    @Test(dataProvider = "intBinaryOpMaskProvider")
1873
    static void addInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1874
                                          IntFunction<boolean[]> fm) {
1875
        int[] a = fa.apply(SPECIES.length());
1876
        int[] b = fb.apply(SPECIES.length());
1877
        int[] r = fr.apply(SPECIES.length());
1878
        boolean[] mask = fm.apply(SPECIES.length());
1879
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1880

1881
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1882
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1883
            av.add(b[i], vmask).intoArray(r, i);
1884
        }
1885

1886
        assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::add);
1887
    }
1888

1889
    @Test(dataProvider = "intBinaryOpProvider")
1890
    static void subInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1891
        int[] a = fa.apply(SPECIES.length());
1892
        int[] b = fb.apply(SPECIES.length());
1893
        int[] r = fr.apply(SPECIES.length());
1894

1895
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1896
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1897
            av.sub(b[i]).intoArray(r, i);
1898
        }
1899

1900
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::sub);
1901
    }
1902

1903
    @Test(dataProvider = "intBinaryOpMaskProvider")
1904
    static void subInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1905
                                          IntFunction<boolean[]> fm) {
1906
        int[] a = fa.apply(SPECIES.length());
1907
        int[] b = fb.apply(SPECIES.length());
1908
        int[] r = fr.apply(SPECIES.length());
1909
        boolean[] mask = fm.apply(SPECIES.length());
1910
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1911

1912
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1913
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1914
            av.sub(b[i], vmask).intoArray(r, i);
1915
        }
1916

1917
        assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::sub);
1918
    }
1919

1920
    @Test(dataProvider = "intBinaryOpProvider")
1921
    static void mulInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1922
        int[] a = fa.apply(SPECIES.length());
1923
        int[] b = fb.apply(SPECIES.length());
1924
        int[] r = fr.apply(SPECIES.length());
1925

1926
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1927
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1928
            av.mul(b[i]).intoArray(r, i);
1929
        }
1930

1931
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::mul);
1932
    }
1933

1934
    @Test(dataProvider = "intBinaryOpMaskProvider")
1935
    static void mulInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1936
                                          IntFunction<boolean[]> fm) {
1937
        int[] a = fa.apply(SPECIES.length());
1938
        int[] b = fb.apply(SPECIES.length());
1939
        int[] r = fr.apply(SPECIES.length());
1940
        boolean[] mask = fm.apply(SPECIES.length());
1941
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1942

1943
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1944
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1945
            av.mul(b[i], vmask).intoArray(r, i);
1946
        }
1947

1948
        assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::mul);
1949
    }
1950

1951

1952

1953

1954
    @Test(dataProvider = "intBinaryOpProvider")
1955
    static void divInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1956
        int[] a = fa.apply(SPECIES.length());
1957
        int[] b = fb.apply(SPECIES.length());
1958
        int[] r = fr.apply(SPECIES.length());
1959

1960
        replaceZero(b, (int) 1);
1961

1962
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1963
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1964
            av.div(b[i]).intoArray(r, i);
1965
        }
1966

1967
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::div);
1968
    }
1969

1970

1971

1972
    @Test(dataProvider = "intBinaryOpMaskProvider")
1973
    static void divInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1974
                                          IntFunction<boolean[]> fm) {
1975
        int[] a = fa.apply(SPECIES.length());
1976
        int[] b = fb.apply(SPECIES.length());
1977
        int[] r = fr.apply(SPECIES.length());
1978
        boolean[] mask = fm.apply(SPECIES.length());
1979
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1980

1981
        replaceZero(b, (int) 1);
1982

1983
        for (int i = 0; i < a.length; i += SPECIES.length()) {
1984
            IntVector av = IntVector.fromArray(SPECIES, a, i);
1985
            av.div(b[i], vmask).intoArray(r, i);
1986
        }
1987

1988
        assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::div);
1989
    }
1990

1991

1992

1993
    @Test(dataProvider = "intBinaryOpProvider")
1994
    static void ORInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1995
        int[] a = fa.apply(SPECIES.length());
1996
        int[] b = fb.apply(SPECIES.length());
1997
        int[] r = fr.apply(SPECIES.length());
1998

1999
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2000
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2001
            av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
2002
        }
2003

2004
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::OR);
2005
    }
2006

2007
    @Test(dataProvider = "intBinaryOpProvider")
2008
    static void orInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2009
        int[] a = fa.apply(SPECIES.length());
2010
        int[] b = fb.apply(SPECIES.length());
2011
        int[] r = fr.apply(SPECIES.length());
2012

2013
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2014
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2015
            av.or(b[i]).intoArray(r, i);
2016
        }
2017

2018
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::or);
2019
    }
2020

2021

2022

2023
    @Test(dataProvider = "intBinaryOpMaskProvider")
2024
    static void ORInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2025
                                          IntFunction<boolean[]> fm) {
2026
        int[] a = fa.apply(SPECIES.length());
2027
        int[] b = fb.apply(SPECIES.length());
2028
        int[] r = fr.apply(SPECIES.length());
2029
        boolean[] mask = fm.apply(SPECIES.length());
2030
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2031

2032
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2033
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2034
            av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
2035
        }
2036

2037
        assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::OR);
2038
    }
2039

2040

2041

2042
    @Test(dataProvider = "intBinaryOpProvider")
2043
    static void ANDInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2044
        int[] a = fa.apply(SPECIES.length());
2045
        int[] b = fb.apply(SPECIES.length());
2046
        int[] r = fr.apply(SPECIES.length());
2047

2048
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2049
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2050
            av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
2051
        }
2052

2053
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::AND);
2054
    }
2055

2056
    @Test(dataProvider = "intBinaryOpProvider")
2057
    static void andInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2058
        int[] a = fa.apply(SPECIES.length());
2059
        int[] b = fb.apply(SPECIES.length());
2060
        int[] r = fr.apply(SPECIES.length());
2061

2062
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2063
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2064
            av.and(b[i]).intoArray(r, i);
2065
        }
2066

2067
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::and);
2068
    }
2069

2070

2071

2072
    @Test(dataProvider = "intBinaryOpMaskProvider")
2073
    static void ANDInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2074
                                          IntFunction<boolean[]> fm) {
2075
        int[] a = fa.apply(SPECIES.length());
2076
        int[] b = fb.apply(SPECIES.length());
2077
        int[] r = fr.apply(SPECIES.length());
2078
        boolean[] mask = fm.apply(SPECIES.length());
2079
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2080

2081
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2082
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2083
            av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
2084
        }
2085

2086
        assertBroadcastArraysEquals(r, a, b, mask, Int128VectorTests::AND);
2087
    }
2088

2089

2090

2091
    @Test(dataProvider = "intBinaryOpProvider")
2092
    static void ORInt128VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2093
        int[] a = fa.apply(SPECIES.length());
2094
        int[] b = fb.apply(SPECIES.length());
2095
        int[] r = fr.apply(SPECIES.length());
2096

2097
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2098
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2099
            av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
2100
        }
2101

2102
        assertBroadcastLongArraysEquals(r, a, b, Int128VectorTests::OR);
2103
    }
2104

2105

2106

2107
    @Test(dataProvider = "intBinaryOpMaskProvider")
2108
    static void ORInt128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2109
                                          IntFunction<boolean[]> fm) {
2110
        int[] a = fa.apply(SPECIES.length());
2111
        int[] b = fb.apply(SPECIES.length());
2112
        int[] r = fr.apply(SPECIES.length());
2113
        boolean[] mask = fm.apply(SPECIES.length());
2114
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2115

2116
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2117
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2118
            av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
2119
        }
2120

2121
        assertBroadcastLongArraysEquals(r, a, b, mask, Int128VectorTests::OR);
2122
    }
2123

2124

2125
    @Test(dataProvider = "intBinaryOpProvider")
2126
    static void ADDInt128VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2127
        int[] a = fa.apply(SPECIES.length());
2128
        int[] b = fb.apply(SPECIES.length());
2129
        int[] r = fr.apply(SPECIES.length());
2130

2131
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2132
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2133
            av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2134
        }
2135

2136
        assertBroadcastLongArraysEquals(r, a, b, Int128VectorTests::ADD);
2137
    }
2138

2139
    @Test(dataProvider = "intBinaryOpMaskProvider")
2140
    static void ADDInt128VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2141
                                          IntFunction<boolean[]> fm) {
2142
        int[] a = fa.apply(SPECIES.length());
2143
        int[] b = fb.apply(SPECIES.length());
2144
        int[] r = fr.apply(SPECIES.length());
2145
        boolean[] mask = fm.apply(SPECIES.length());
2146
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2147

2148
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2149
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2150
            av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2151
        }
2152

2153
        assertBroadcastLongArraysEquals(r, a, b, mask, Int128VectorTests::ADD);
2154
    }
2155

2156
    static int LSHL(int a, int b) {
2157
        return (int)((a << b));
2158
    }
2159

2160
    @Test(dataProvider = "intBinaryOpProvider")
2161
    static void LSHLInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2162
        int[] a = fa.apply(SPECIES.length());
2163
        int[] b = fb.apply(SPECIES.length());
2164
        int[] r = fr.apply(SPECIES.length());
2165

2166
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2167
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2168
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2169
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
2170
                av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
2171
            }
2172
        }
2173

2174
        assertArraysEquals(r, a, b, Int128VectorTests::LSHL);
2175
    }
2176

2177

2178

2179
    @Test(dataProvider = "intBinaryOpMaskProvider")
2180
    static void LSHLInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2181
                                          IntFunction<boolean[]> fm) {
2182
        int[] a = fa.apply(SPECIES.length());
2183
        int[] b = fb.apply(SPECIES.length());
2184
        int[] r = fr.apply(SPECIES.length());
2185
        boolean[] mask = fm.apply(SPECIES.length());
2186
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2187

2188
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2189
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2190
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2191
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
2192
                av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
2193
            }
2194
        }
2195

2196
        assertArraysEquals(r, a, b, mask, Int128VectorTests::LSHL);
2197
    }
2198

2199

2200

2201

2202

2203

2204
    static int ASHR(int a, int b) {
2205
        return (int)((a >> b));
2206
    }
2207

2208
    @Test(dataProvider = "intBinaryOpProvider")
2209
    static void ASHRInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2210
        int[] a = fa.apply(SPECIES.length());
2211
        int[] b = fb.apply(SPECIES.length());
2212
        int[] r = fr.apply(SPECIES.length());
2213

2214
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2215
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2216
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2217
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
2218
                av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
2219
            }
2220
        }
2221

2222
        assertArraysEquals(r, a, b, Int128VectorTests::ASHR);
2223
    }
2224

2225

2226

2227
    @Test(dataProvider = "intBinaryOpMaskProvider")
2228
    static void ASHRInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2229
                                          IntFunction<boolean[]> fm) {
2230
        int[] a = fa.apply(SPECIES.length());
2231
        int[] b = fb.apply(SPECIES.length());
2232
        int[] r = fr.apply(SPECIES.length());
2233
        boolean[] mask = fm.apply(SPECIES.length());
2234
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2235

2236
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2237
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2238
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2239
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
2240
                av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
2241
            }
2242
        }
2243

2244
        assertArraysEquals(r, a, b, mask, Int128VectorTests::ASHR);
2245
    }
2246

2247

2248

2249

2250

2251

2252
    static int LSHR(int a, int b) {
2253
        return (int)((a >>> b));
2254
    }
2255

2256
    @Test(dataProvider = "intBinaryOpProvider")
2257
    static void LSHRInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2258
        int[] a = fa.apply(SPECIES.length());
2259
        int[] b = fb.apply(SPECIES.length());
2260
        int[] r = fr.apply(SPECIES.length());
2261

2262
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2263
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2264
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2265
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
2266
                av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
2267
            }
2268
        }
2269

2270
        assertArraysEquals(r, a, b, Int128VectorTests::LSHR);
2271
    }
2272

2273

2274

2275
    @Test(dataProvider = "intBinaryOpMaskProvider")
2276
    static void LSHRInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2277
                                          IntFunction<boolean[]> fm) {
2278
        int[] a = fa.apply(SPECIES.length());
2279
        int[] b = fb.apply(SPECIES.length());
2280
        int[] r = fr.apply(SPECIES.length());
2281
        boolean[] mask = fm.apply(SPECIES.length());
2282
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2283

2284
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2285
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2286
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2287
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
2288
                av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
2289
            }
2290
        }
2291

2292
        assertArraysEquals(r, a, b, mask, Int128VectorTests::LSHR);
2293
    }
2294

2295

2296

2297

2298

2299

2300
    static int LSHL_unary(int a, int b) {
2301
        return (int)((a << b));
2302
    }
2303

2304
    @Test(dataProvider = "intBinaryOpProvider")
2305
    static void LSHLInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2306
        int[] a = fa.apply(SPECIES.length());
2307
        int[] b = fb.apply(SPECIES.length());
2308
        int[] r = fr.apply(SPECIES.length());
2309

2310
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2311
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2312
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2313
                av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
2314
            }
2315
        }
2316

2317
        assertShiftArraysEquals(r, a, b, Int128VectorTests::LSHL_unary);
2318
    }
2319

2320

2321

2322
    @Test(dataProvider = "intBinaryOpMaskProvider")
2323
    static void LSHLInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
2324
                                          IntFunction<boolean[]> fm) {
2325
        int[] a = fa.apply(SPECIES.length());
2326
        int[] b = fb.apply(SPECIES.length());
2327
        int[] r = fr.apply(SPECIES.length());
2328
        boolean[] mask = fm.apply(SPECIES.length());
2329
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2330

2331
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2332
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2333
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2334
                av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
2335
            }
2336
        }
2337

2338
        assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::LSHL_unary);
2339
    }
2340

2341

2342

2343

2344

2345

2346
    static int LSHR_unary(int a, int b) {
2347
        return (int)((a >>> b));
2348
    }
2349

2350
    @Test(dataProvider = "intBinaryOpProvider")
2351
    static void LSHRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2352
        int[] a = fa.apply(SPECIES.length());
2353
        int[] b = fb.apply(SPECIES.length());
2354
        int[] r = fr.apply(SPECIES.length());
2355

2356
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2357
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2358
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2359
                av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
2360
            }
2361
        }
2362

2363
        assertShiftArraysEquals(r, a, b, Int128VectorTests::LSHR_unary);
2364
    }
2365

2366

2367

2368
    @Test(dataProvider = "intBinaryOpMaskProvider")
2369
    static void LSHRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
2370
                                          IntFunction<boolean[]> fm) {
2371
        int[] a = fa.apply(SPECIES.length());
2372
        int[] b = fb.apply(SPECIES.length());
2373
        int[] r = fr.apply(SPECIES.length());
2374
        boolean[] mask = fm.apply(SPECIES.length());
2375
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2376

2377
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2378
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2379
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2380
                av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
2381
            }
2382
        }
2383

2384
        assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::LSHR_unary);
2385
    }
2386

2387

2388

2389

2390

2391

2392
    static int ASHR_unary(int a, int b) {
2393
        return (int)((a >> b));
2394
    }
2395

2396
    @Test(dataProvider = "intBinaryOpProvider")
2397
    static void ASHRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2398
        int[] a = fa.apply(SPECIES.length());
2399
        int[] b = fb.apply(SPECIES.length());
2400
        int[] r = fr.apply(SPECIES.length());
2401

2402
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2403
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2404
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2405
                av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
2406
            }
2407
        }
2408

2409
        assertShiftArraysEquals(r, a, b, Int128VectorTests::ASHR_unary);
2410
    }
2411

2412

2413

2414
    @Test(dataProvider = "intBinaryOpMaskProvider")
2415
    static void ASHRInt128VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
2416
                                          IntFunction<boolean[]> fm) {
2417
        int[] a = fa.apply(SPECIES.length());
2418
        int[] b = fb.apply(SPECIES.length());
2419
        int[] r = fr.apply(SPECIES.length());
2420
        boolean[] mask = fm.apply(SPECIES.length());
2421
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2422

2423
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2424
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2425
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2426
                av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
2427
            }
2428
        }
2429

2430
        assertShiftArraysEquals(r, a, b, mask, Int128VectorTests::ASHR_unary);
2431
    }
2432

2433

2434

2435

2436

2437
    static int MIN(int a, int b) {
2438
        return (int)(Math.min(a, b));
2439
    }
2440

2441
    @Test(dataProvider = "intBinaryOpProvider")
2442
    static void MINInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2443
        int[] a = fa.apply(SPECIES.length());
2444
        int[] b = fb.apply(SPECIES.length());
2445
        int[] r = fr.apply(SPECIES.length());
2446

2447
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2448
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2449
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2450
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
2451
                av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
2452
            }
2453
        }
2454

2455
        assertArraysEquals(r, a, b, Int128VectorTests::MIN);
2456
    }
2457
    static int min(int a, int b) {
2458
        return (int)(Math.min(a, b));
2459
    }
2460

2461
    @Test(dataProvider = "intBinaryOpProvider")
2462
    static void minInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2463
        int[] a = fa.apply(SPECIES.length());
2464
        int[] b = fb.apply(SPECIES.length());
2465
        int[] r = fr.apply(SPECIES.length());
2466

2467
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2468
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2469
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
2470
            av.min(bv).intoArray(r, i);
2471
        }
2472

2473
        assertArraysEquals(r, a, b, Int128VectorTests::min);
2474
    }
2475
    static int MAX(int a, int b) {
2476
        return (int)(Math.max(a, b));
2477
    }
2478

2479
    @Test(dataProvider = "intBinaryOpProvider")
2480
    static void MAXInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2481
        int[] a = fa.apply(SPECIES.length());
2482
        int[] b = fb.apply(SPECIES.length());
2483
        int[] r = fr.apply(SPECIES.length());
2484

2485
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2486
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2487
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2488
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
2489
                av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
2490
            }
2491
        }
2492

2493
        assertArraysEquals(r, a, b, Int128VectorTests::MAX);
2494
    }
2495
    static int max(int a, int b) {
2496
        return (int)(Math.max(a, b));
2497
    }
2498

2499
    @Test(dataProvider = "intBinaryOpProvider")
2500
    static void maxInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2501
        int[] a = fa.apply(SPECIES.length());
2502
        int[] b = fb.apply(SPECIES.length());
2503
        int[] r = fr.apply(SPECIES.length());
2504

2505
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2506
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2507
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
2508
            av.max(bv).intoArray(r, i);
2509
        }
2510

2511
        assertArraysEquals(r, a, b, Int128VectorTests::max);
2512
    }
2513

2514
    @Test(dataProvider = "intBinaryOpProvider")
2515
    static void MINInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2516
        int[] a = fa.apply(SPECIES.length());
2517
        int[] b = fb.apply(SPECIES.length());
2518
        int[] r = fr.apply(SPECIES.length());
2519

2520
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2521
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2522
            av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
2523
        }
2524

2525
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::MIN);
2526
    }
2527

2528
    @Test(dataProvider = "intBinaryOpProvider")
2529
    static void minInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2530
        int[] a = fa.apply(SPECIES.length());
2531
        int[] b = fb.apply(SPECIES.length());
2532
        int[] r = fr.apply(SPECIES.length());
2533

2534
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2535
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2536
            av.min(b[i]).intoArray(r, i);
2537
        }
2538

2539
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::min);
2540
    }
2541

2542
    @Test(dataProvider = "intBinaryOpProvider")
2543
    static void MAXInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2544
        int[] a = fa.apply(SPECIES.length());
2545
        int[] b = fb.apply(SPECIES.length());
2546
        int[] r = fr.apply(SPECIES.length());
2547

2548
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2549
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2550
            av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
2551
        }
2552

2553
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::MAX);
2554
    }
2555

2556
    @Test(dataProvider = "intBinaryOpProvider")
2557
    static void maxInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2558
        int[] a = fa.apply(SPECIES.length());
2559
        int[] b = fb.apply(SPECIES.length());
2560
        int[] r = fr.apply(SPECIES.length());
2561

2562
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2563
            IntVector av = IntVector.fromArray(SPECIES, a, i);
2564
            av.max(b[i]).intoArray(r, i);
2565
        }
2566

2567
        assertBroadcastArraysEquals(r, a, b, Int128VectorTests::max);
2568
    }
2569

2570
    static int ANDReduce(int[] a, int idx) {
2571
        int res = -1;
2572
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
2573
            res &= a[i];
2574
        }
2575

2576
        return res;
2577
    }
2578

2579
    static int ANDReduceAll(int[] a) {
2580
        int res = -1;
2581
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2582
            res &= ANDReduce(a, i);
2583
        }
2584

2585
        return res;
2586
    }
2587

2588

2589
    @Test(dataProvider = "intUnaryOpProvider")
2590
    static void ANDReduceInt128VectorTests(IntFunction<int[]> fa) {
2591
        int[] a = fa.apply(SPECIES.length());
2592
        int[] r = fr.apply(SPECIES.length());
2593
        int ra = -1;
2594

2595
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2596
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2597
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2598
                r[i] = av.reduceLanes(VectorOperators.AND);
2599
            }
2600
        }
2601

2602
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2603
            ra = -1;
2604
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2605
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2606
                ra &= av.reduceLanes(VectorOperators.AND);
2607
            }
2608
        }
2609

2610
        assertReductionArraysEquals(r, ra, a,
2611
                Int128VectorTests::ANDReduce, Int128VectorTests::ANDReduceAll);
2612
    }
2613

2614

2615
    static int ANDReduceMasked(int[] a, int idx, boolean[] mask) {
2616
        int res = -1;
2617
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
2618
            if (mask[i % SPECIES.length()])
2619
                res &= a[i];
2620
        }
2621

2622
        return res;
2623
    }
2624

2625
    static int ANDReduceAllMasked(int[] a, boolean[] mask) {
2626
        int res = -1;
2627
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2628
            res &= ANDReduceMasked(a, i, mask);
2629
        }
2630

2631
        return res;
2632
    }
2633

2634

2635
    @Test(dataProvider = "intUnaryOpMaskProvider")
2636
    static void ANDReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2637
        int[] a = fa.apply(SPECIES.length());
2638
        int[] r = fr.apply(SPECIES.length());
2639
        boolean[] mask = fm.apply(SPECIES.length());
2640
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2641
        int ra = -1;
2642

2643
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2644
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2645
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2646
                r[i] = av.reduceLanes(VectorOperators.AND, vmask);
2647
            }
2648
        }
2649

2650
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2651
            ra = -1;
2652
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2653
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2654
                ra &= av.reduceLanes(VectorOperators.AND, vmask);
2655
            }
2656
        }
2657

2658
        assertReductionArraysEqualsMasked(r, ra, a, mask,
2659
                Int128VectorTests::ANDReduceMasked, Int128VectorTests::ANDReduceAllMasked);
2660
    }
2661

2662

2663
    static int ORReduce(int[] a, int idx) {
2664
        int res = 0;
2665
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
2666
            res |= a[i];
2667
        }
2668

2669
        return res;
2670
    }
2671

2672
    static int ORReduceAll(int[] a) {
2673
        int res = 0;
2674
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2675
            res |= ORReduce(a, i);
2676
        }
2677

2678
        return res;
2679
    }
2680

2681

2682
    @Test(dataProvider = "intUnaryOpProvider")
2683
    static void ORReduceInt128VectorTests(IntFunction<int[]> fa) {
2684
        int[] a = fa.apply(SPECIES.length());
2685
        int[] r = fr.apply(SPECIES.length());
2686
        int ra = 0;
2687

2688
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2689
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2690
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2691
                r[i] = av.reduceLanes(VectorOperators.OR);
2692
            }
2693
        }
2694

2695
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2696
            ra = 0;
2697
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2698
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2699
                ra |= av.reduceLanes(VectorOperators.OR);
2700
            }
2701
        }
2702

2703
        assertReductionArraysEquals(r, ra, a,
2704
                Int128VectorTests::ORReduce, Int128VectorTests::ORReduceAll);
2705
    }
2706

2707

2708
    static int ORReduceMasked(int[] a, int idx, boolean[] mask) {
2709
        int res = 0;
2710
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
2711
            if (mask[i % SPECIES.length()])
2712
                res |= a[i];
2713
        }
2714

2715
        return res;
2716
    }
2717

2718
    static int ORReduceAllMasked(int[] a, boolean[] mask) {
2719
        int res = 0;
2720
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2721
            res |= ORReduceMasked(a, i, mask);
2722
        }
2723

2724
        return res;
2725
    }
2726

2727

2728
    @Test(dataProvider = "intUnaryOpMaskProvider")
2729
    static void ORReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2730
        int[] a = fa.apply(SPECIES.length());
2731
        int[] r = fr.apply(SPECIES.length());
2732
        boolean[] mask = fm.apply(SPECIES.length());
2733
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2734
        int ra = 0;
2735

2736
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2737
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2738
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2739
                r[i] = av.reduceLanes(VectorOperators.OR, vmask);
2740
            }
2741
        }
2742

2743
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2744
            ra = 0;
2745
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2746
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2747
                ra |= av.reduceLanes(VectorOperators.OR, vmask);
2748
            }
2749
        }
2750

2751
        assertReductionArraysEqualsMasked(r, ra, a, mask,
2752
                Int128VectorTests::ORReduceMasked, Int128VectorTests::ORReduceAllMasked);
2753
    }
2754

2755

2756
    static int XORReduce(int[] a, int idx) {
2757
        int res = 0;
2758
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
2759
            res ^= a[i];
2760
        }
2761

2762
        return res;
2763
    }
2764

2765
    static int XORReduceAll(int[] a) {
2766
        int res = 0;
2767
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2768
            res ^= XORReduce(a, i);
2769
        }
2770

2771
        return res;
2772
    }
2773

2774

2775
    @Test(dataProvider = "intUnaryOpProvider")
2776
    static void XORReduceInt128VectorTests(IntFunction<int[]> fa) {
2777
        int[] a = fa.apply(SPECIES.length());
2778
        int[] r = fr.apply(SPECIES.length());
2779
        int ra = 0;
2780

2781
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2782
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2783
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2784
                r[i] = av.reduceLanes(VectorOperators.XOR);
2785
            }
2786
        }
2787

2788
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2789
            ra = 0;
2790
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2791
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2792
                ra ^= av.reduceLanes(VectorOperators.XOR);
2793
            }
2794
        }
2795

2796
        assertReductionArraysEquals(r, ra, a,
2797
                Int128VectorTests::XORReduce, Int128VectorTests::XORReduceAll);
2798
    }
2799

2800

2801
    static int XORReduceMasked(int[] a, int idx, boolean[] mask) {
2802
        int res = 0;
2803
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
2804
            if (mask[i % SPECIES.length()])
2805
                res ^= a[i];
2806
        }
2807

2808
        return res;
2809
    }
2810

2811
    static int XORReduceAllMasked(int[] a, boolean[] mask) {
2812
        int res = 0;
2813
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2814
            res ^= XORReduceMasked(a, i, mask);
2815
        }
2816

2817
        return res;
2818
    }
2819

2820

2821
    @Test(dataProvider = "intUnaryOpMaskProvider")
2822
    static void XORReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2823
        int[] a = fa.apply(SPECIES.length());
2824
        int[] r = fr.apply(SPECIES.length());
2825
        boolean[] mask = fm.apply(SPECIES.length());
2826
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2827
        int ra = 0;
2828

2829
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2830
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2831
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2832
                r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
2833
            }
2834
        }
2835

2836
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2837
            ra = 0;
2838
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2839
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2840
                ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
2841
            }
2842
        }
2843

2844
        assertReductionArraysEqualsMasked(r, ra, a, mask,
2845
                Int128VectorTests::XORReduceMasked, Int128VectorTests::XORReduceAllMasked);
2846
    }
2847

2848
    static int ADDReduce(int[] a, int idx) {
2849
        int res = 0;
2850
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
2851
            res += a[i];
2852
        }
2853

2854
        return res;
2855
    }
2856

2857
    static int ADDReduceAll(int[] a) {
2858
        int res = 0;
2859
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2860
            res += ADDReduce(a, i);
2861
        }
2862

2863
        return res;
2864
    }
2865
    @Test(dataProvider = "intUnaryOpProvider")
2866
    static void ADDReduceInt128VectorTests(IntFunction<int[]> fa) {
2867
        int[] a = fa.apply(SPECIES.length());
2868
        int[] r = fr.apply(SPECIES.length());
2869
        int ra = 0;
2870

2871
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2872
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2873
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2874
                r[i] = av.reduceLanes(VectorOperators.ADD);
2875
            }
2876
        }
2877

2878
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2879
            ra = 0;
2880
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2881
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2882
                ra += av.reduceLanes(VectorOperators.ADD);
2883
            }
2884
        }
2885

2886
        assertReductionArraysEquals(r, ra, a,
2887
                Int128VectorTests::ADDReduce, Int128VectorTests::ADDReduceAll);
2888
    }
2889
    static int ADDReduceMasked(int[] a, int idx, boolean[] mask) {
2890
        int res = 0;
2891
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
2892
            if (mask[i % SPECIES.length()])
2893
                res += a[i];
2894
        }
2895

2896
        return res;
2897
    }
2898

2899
    static int ADDReduceAllMasked(int[] a, boolean[] mask) {
2900
        int res = 0;
2901
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2902
            res += ADDReduceMasked(a, i, mask);
2903
        }
2904

2905
        return res;
2906
    }
2907
    @Test(dataProvider = "intUnaryOpMaskProvider")
2908
    static void ADDReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2909
        int[] a = fa.apply(SPECIES.length());
2910
        int[] r = fr.apply(SPECIES.length());
2911
        boolean[] mask = fm.apply(SPECIES.length());
2912
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2913
        int ra = 0;
2914

2915
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2916
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2917
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2918
                r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
2919
            }
2920
        }
2921

2922
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2923
            ra = 0;
2924
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2925
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2926
                ra += av.reduceLanes(VectorOperators.ADD, vmask);
2927
            }
2928
        }
2929

2930
        assertReductionArraysEqualsMasked(r, ra, a, mask,
2931
                Int128VectorTests::ADDReduceMasked, Int128VectorTests::ADDReduceAllMasked);
2932
    }
2933
    static int MULReduce(int[] a, int idx) {
2934
        int res = 1;
2935
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
2936
            res *= a[i];
2937
        }
2938

2939
        return res;
2940
    }
2941

2942
    static int MULReduceAll(int[] a) {
2943
        int res = 1;
2944
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2945
            res *= MULReduce(a, i);
2946
        }
2947

2948
        return res;
2949
    }
2950
    @Test(dataProvider = "intUnaryOpProvider")
2951
    static void MULReduceInt128VectorTests(IntFunction<int[]> fa) {
2952
        int[] a = fa.apply(SPECIES.length());
2953
        int[] r = fr.apply(SPECIES.length());
2954
        int ra = 1;
2955

2956
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2957
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2958
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2959
                r[i] = av.reduceLanes(VectorOperators.MUL);
2960
            }
2961
        }
2962

2963
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
2964
            ra = 1;
2965
            for (int i = 0; i < a.length; i += SPECIES.length()) {
2966
                IntVector av = IntVector.fromArray(SPECIES, a, i);
2967
                ra *= av.reduceLanes(VectorOperators.MUL);
2968
            }
2969
        }
2970

2971
        assertReductionArraysEquals(r, ra, a,
2972
                Int128VectorTests::MULReduce, Int128VectorTests::MULReduceAll);
2973
    }
2974
    static int MULReduceMasked(int[] a, int idx, boolean[] mask) {
2975
        int res = 1;
2976
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
2977
            if (mask[i % SPECIES.length()])
2978
                res *= a[i];
2979
        }
2980

2981
        return res;
2982
    }
2983

2984
    static int MULReduceAllMasked(int[] a, boolean[] mask) {
2985
        int res = 1;
2986
        for (int i = 0; i < a.length; i += SPECIES.length()) {
2987
            res *= MULReduceMasked(a, i, mask);
2988
        }
2989

2990
        return res;
2991
    }
2992
    @Test(dataProvider = "intUnaryOpMaskProvider")
2993
    static void MULReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2994
        int[] a = fa.apply(SPECIES.length());
2995
        int[] r = fr.apply(SPECIES.length());
2996
        boolean[] mask = fm.apply(SPECIES.length());
2997
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2998
        int ra = 1;
2999

3000
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3001
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3002
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3003
                r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
3004
            }
3005
        }
3006

3007
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3008
            ra = 1;
3009
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3010
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3011
                ra *= av.reduceLanes(VectorOperators.MUL, vmask);
3012
            }
3013
        }
3014

3015
        assertReductionArraysEqualsMasked(r, ra, a, mask,
3016
                Int128VectorTests::MULReduceMasked, Int128VectorTests::MULReduceAllMasked);
3017
    }
3018
    static int MINReduce(int[] a, int idx) {
3019
        int res = Integer.MAX_VALUE;
3020
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
3021
            res = (int)Math.min(res, a[i]);
3022
        }
3023

3024
        return res;
3025
    }
3026

3027
    static int MINReduceAll(int[] a) {
3028
        int res = Integer.MAX_VALUE;
3029
        for (int i = 0; i < a.length; i++) {
3030
            res = (int)Math.min(res, a[i]);
3031
        }
3032

3033
        return res;
3034
    }
3035
    @Test(dataProvider = "intUnaryOpProvider")
3036
    static void MINReduceInt128VectorTests(IntFunction<int[]> fa) {
3037
        int[] a = fa.apply(SPECIES.length());
3038
        int[] r = fr.apply(SPECIES.length());
3039
        int ra = Integer.MAX_VALUE;
3040

3041
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3042
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3043
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3044
                r[i] = av.reduceLanes(VectorOperators.MIN);
3045
            }
3046
        }
3047

3048
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3049
            ra = Integer.MAX_VALUE;
3050
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3051
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3052
                ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN));
3053
            }
3054
        }
3055

3056
        assertReductionArraysEquals(r, ra, a,
3057
                Int128VectorTests::MINReduce, Int128VectorTests::MINReduceAll);
3058
    }
3059
    static int MINReduceMasked(int[] a, int idx, boolean[] mask) {
3060
        int res = Integer.MAX_VALUE;
3061
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
3062
            if(mask[i % SPECIES.length()])
3063
                res = (int)Math.min(res, a[i]);
3064
        }
3065

3066
        return res;
3067
    }
3068

3069
    static int MINReduceAllMasked(int[] a, boolean[] mask) {
3070
        int res = Integer.MAX_VALUE;
3071
        for (int i = 0; i < a.length; i++) {
3072
            if(mask[i % SPECIES.length()])
3073
                res = (int)Math.min(res, a[i]);
3074
        }
3075

3076
        return res;
3077
    }
3078
    @Test(dataProvider = "intUnaryOpMaskProvider")
3079
    static void MINReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3080
        int[] a = fa.apply(SPECIES.length());
3081
        int[] r = fr.apply(SPECIES.length());
3082
        boolean[] mask = fm.apply(SPECIES.length());
3083
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3084
        int ra = Integer.MAX_VALUE;
3085

3086
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3087
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3088
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3089
                r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
3090
            }
3091
        }
3092

3093
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3094
            ra = Integer.MAX_VALUE;
3095
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3096
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3097
                ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
3098
            }
3099
        }
3100

3101
        assertReductionArraysEqualsMasked(r, ra, a, mask,
3102
                Int128VectorTests::MINReduceMasked, Int128VectorTests::MINReduceAllMasked);
3103
    }
3104
    static int MAXReduce(int[] a, int idx) {
3105
        int res = Integer.MIN_VALUE;
3106
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
3107
            res = (int)Math.max(res, a[i]);
3108
        }
3109

3110
        return res;
3111
    }
3112

3113
    static int MAXReduceAll(int[] a) {
3114
        int res = Integer.MIN_VALUE;
3115
        for (int i = 0; i < a.length; i++) {
3116
            res = (int)Math.max(res, a[i]);
3117
        }
3118

3119
        return res;
3120
    }
3121
    @Test(dataProvider = "intUnaryOpProvider")
3122
    static void MAXReduceInt128VectorTests(IntFunction<int[]> fa) {
3123
        int[] a = fa.apply(SPECIES.length());
3124
        int[] r = fr.apply(SPECIES.length());
3125
        int ra = Integer.MIN_VALUE;
3126

3127
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3128
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3129
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3130
                r[i] = av.reduceLanes(VectorOperators.MAX);
3131
            }
3132
        }
3133

3134
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3135
            ra = Integer.MIN_VALUE;
3136
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3137
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3138
                ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX));
3139
            }
3140
        }
3141

3142
        assertReductionArraysEquals(r, ra, a,
3143
                Int128VectorTests::MAXReduce, Int128VectorTests::MAXReduceAll);
3144
    }
3145
    static int MAXReduceMasked(int[] a, int idx, boolean[] mask) {
3146
        int res = Integer.MIN_VALUE;
3147
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
3148
            if(mask[i % SPECIES.length()])
3149
                res = (int)Math.max(res, a[i]);
3150
        }
3151

3152
        return res;
3153
    }
3154

3155
    static int MAXReduceAllMasked(int[] a, boolean[] mask) {
3156
        int res = Integer.MIN_VALUE;
3157
        for (int i = 0; i < a.length; i++) {
3158
            if(mask[i % SPECIES.length()])
3159
                res = (int)Math.max(res, a[i]);
3160
        }
3161

3162
        return res;
3163
    }
3164
    @Test(dataProvider = "intUnaryOpMaskProvider")
3165
    static void MAXReduceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3166
        int[] a = fa.apply(SPECIES.length());
3167
        int[] r = fr.apply(SPECIES.length());
3168
        boolean[] mask = fm.apply(SPECIES.length());
3169
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3170
        int ra = Integer.MIN_VALUE;
3171

3172
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3173
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3174
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3175
                r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
3176
            }
3177
        }
3178

3179
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3180
            ra = Integer.MIN_VALUE;
3181
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3182
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3183
                ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
3184
            }
3185
        }
3186

3187
        assertReductionArraysEqualsMasked(r, ra, a, mask,
3188
                Int128VectorTests::MAXReduceMasked, Int128VectorTests::MAXReduceAllMasked);
3189
    }
3190

3191
    static boolean anyTrue(boolean[] a, int idx) {
3192
        boolean res = false;
3193
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
3194
            res |= a[i];
3195
        }
3196

3197
        return res;
3198
    }
3199

3200

3201
    @Test(dataProvider = "boolUnaryOpProvider")
3202
    static void anyTrueInt128VectorTests(IntFunction<boolean[]> fm) {
3203
        boolean[] mask = fm.apply(SPECIES.length());
3204
        boolean[] r = fmr.apply(SPECIES.length());
3205

3206
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3207
            for (int i = 0; i < mask.length; i += SPECIES.length()) {
3208
                VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
3209
                r[i] = vmask.anyTrue();
3210
            }
3211
        }
3212

3213
        assertReductionBoolArraysEquals(r, mask, Int128VectorTests::anyTrue);
3214
    }
3215

3216

3217
    static boolean allTrue(boolean[] a, int idx) {
3218
        boolean res = true;
3219
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
3220
            res &= a[i];
3221
        }
3222

3223
        return res;
3224
    }
3225

3226

3227
    @Test(dataProvider = "boolUnaryOpProvider")
3228
    static void allTrueInt128VectorTests(IntFunction<boolean[]> fm) {
3229
        boolean[] mask = fm.apply(SPECIES.length());
3230
        boolean[] r = fmr.apply(SPECIES.length());
3231

3232
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3233
            for (int i = 0; i < mask.length; i += SPECIES.length()) {
3234
                VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
3235
                r[i] = vmask.allTrue();
3236
            }
3237
        }
3238

3239
        assertReductionBoolArraysEquals(r, mask, Int128VectorTests::allTrue);
3240
    }
3241

3242

3243
    @Test(dataProvider = "intUnaryOpProvider")
3244
    static void withInt128VectorTests(IntFunction<int []> fa) {
3245
        int[] a = fa.apply(SPECIES.length());
3246
        int[] r = fr.apply(SPECIES.length());
3247

3248
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3249
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3250
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3251
                av.withLane(0, (int)4).intoArray(r, i);
3252
            }
3253
        }
3254

3255
        assertInsertArraysEquals(r, a, (int)4, 0);
3256
    }
3257
    static boolean testIS_DEFAULT(int a) {
3258
        return bits(a)==0;
3259
    }
3260

3261
    @Test(dataProvider = "intTestOpProvider")
3262
    static void IS_DEFAULTInt128VectorTests(IntFunction<int[]> fa) {
3263
        int[] a = fa.apply(SPECIES.length());
3264

3265
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3266
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3267
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3268
                VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT);
3269

3270
                // Check results as part of computation.
3271
                for (int j = 0; j < SPECIES.length(); j++) {
3272
                    Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
3273
                }
3274
            }
3275
        }
3276
    }
3277

3278
    @Test(dataProvider = "intTestOpMaskProvider")
3279
    static void IS_DEFAULTMaskedInt128VectorTestsSmokeTest(IntFunction<int[]> fa,
3280
                                          IntFunction<boolean[]> fm) {
3281
        int[] a = fa.apply(SPECIES.length());
3282
        boolean[] mask = fm.apply(SPECIES.length());
3283
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3284

3285
        for (int i = 0; i < a.length; i += SPECIES.length()) {
3286
            IntVector av = IntVector.fromArray(SPECIES, a, i);
3287
            VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
3288

3289
            // Check results as part of computation.
3290
            for (int j = 0; j < SPECIES.length(); j++) {
3291
                Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
3292
            }
3293
        }
3294
    }
3295
    static boolean testIS_NEGATIVE(int a) {
3296
        return bits(a)<0;
3297
    }
3298

3299
    @Test(dataProvider = "intTestOpProvider")
3300
    static void IS_NEGATIVEInt128VectorTests(IntFunction<int[]> fa) {
3301
        int[] a = fa.apply(SPECIES.length());
3302

3303
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3304
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3305
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3306
                VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE);
3307

3308
                // Check results as part of computation.
3309
                for (int j = 0; j < SPECIES.length(); j++) {
3310
                    Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
3311
                }
3312
            }
3313
        }
3314
    }
3315

3316
    @Test(dataProvider = "intTestOpMaskProvider")
3317
    static void IS_NEGATIVEMaskedInt128VectorTestsSmokeTest(IntFunction<int[]> fa,
3318
                                          IntFunction<boolean[]> fm) {
3319
        int[] a = fa.apply(SPECIES.length());
3320
        boolean[] mask = fm.apply(SPECIES.length());
3321
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3322

3323
        for (int i = 0; i < a.length; i += SPECIES.length()) {
3324
            IntVector av = IntVector.fromArray(SPECIES, a, i);
3325
            VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
3326

3327
            // Check results as part of computation.
3328
            for (int j = 0; j < SPECIES.length(); j++) {
3329
                Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
3330
            }
3331
        }
3332
    }
3333

3334

3335

3336

3337
    @Test(dataProvider = "intCompareOpProvider")
3338
    static void LTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3339
        int[] a = fa.apply(SPECIES.length());
3340
        int[] b = fb.apply(SPECIES.length());
3341

3342
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3343
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3344
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3345
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3346
                VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv);
3347

3348
                // Check results as part of computation.
3349
                for (int j = 0; j < SPECIES.length(); j++) {
3350
                    Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3351
                }
3352
            }
3353
        }
3354
    }
3355

3356

3357
    @Test(dataProvider = "intCompareOpProvider")
3358
    static void ltInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3359
        int[] a = fa.apply(SPECIES.length());
3360
        int[] b = fb.apply(SPECIES.length());
3361

3362
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3363
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3364
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3365
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3366
                VectorMask<Integer> mv = av.lt(bv);
3367

3368
                // Check results as part of computation.
3369
                for (int j = 0; j < SPECIES.length(); j++) {
3370
                    Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3371
                }
3372
            }
3373
        }
3374
    }
3375

3376
    @Test(dataProvider = "intCompareOpMaskProvider")
3377
    static void LTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3378
                                                IntFunction<boolean[]> fm) {
3379
        int[] a = fa.apply(SPECIES.length());
3380
        int[] b = fb.apply(SPECIES.length());
3381
        boolean[] mask = fm.apply(SPECIES.length());
3382

3383
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3384

3385
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3386
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3387
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3388
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3389
                VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv, vmask);
3390

3391
                // Check results as part of computation.
3392
                for (int j = 0; j < SPECIES.length(); j++) {
3393
                    Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
3394
                }
3395
            }
3396
        }
3397
    }
3398

3399

3400
    @Test(dataProvider = "intCompareOpProvider")
3401
    static void GTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3402
        int[] a = fa.apply(SPECIES.length());
3403
        int[] b = fb.apply(SPECIES.length());
3404

3405
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3406
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3407
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3408
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3409
                VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv);
3410

3411
                // Check results as part of computation.
3412
                for (int j = 0; j < SPECIES.length(); j++) {
3413
                    Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
3414
                }
3415
            }
3416
        }
3417
    }
3418

3419
    @Test(dataProvider = "intCompareOpMaskProvider")
3420
    static void GTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3421
                                                IntFunction<boolean[]> fm) {
3422
        int[] a = fa.apply(SPECIES.length());
3423
        int[] b = fb.apply(SPECIES.length());
3424
        boolean[] mask = fm.apply(SPECIES.length());
3425

3426
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3427

3428
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3429
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3430
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3431
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3432
                VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv, vmask);
3433

3434
                // Check results as part of computation.
3435
                for (int j = 0; j < SPECIES.length(); j++) {
3436
                    Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
3437
                }
3438
            }
3439
        }
3440
    }
3441

3442

3443
    @Test(dataProvider = "intCompareOpProvider")
3444
    static void EQInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3445
        int[] a = fa.apply(SPECIES.length());
3446
        int[] b = fb.apply(SPECIES.length());
3447

3448
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3449
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3450
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3451
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3452
                VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv);
3453

3454
                // Check results as part of computation.
3455
                for (int j = 0; j < SPECIES.length(); j++) {
3456
                    Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3457
                }
3458
            }
3459
        }
3460
    }
3461

3462

3463
    @Test(dataProvider = "intCompareOpProvider")
3464
    static void eqInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3465
        int[] a = fa.apply(SPECIES.length());
3466
        int[] b = fb.apply(SPECIES.length());
3467

3468
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3469
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3470
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3471
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3472
                VectorMask<Integer> mv = av.eq(bv);
3473

3474
                // Check results as part of computation.
3475
                for (int j = 0; j < SPECIES.length(); j++) {
3476
                    Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3477
                }
3478
            }
3479
        }
3480
    }
3481

3482
    @Test(dataProvider = "intCompareOpMaskProvider")
3483
    static void EQInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3484
                                                IntFunction<boolean[]> fm) {
3485
        int[] a = fa.apply(SPECIES.length());
3486
        int[] b = fb.apply(SPECIES.length());
3487
        boolean[] mask = fm.apply(SPECIES.length());
3488

3489
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3490

3491
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3492
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3493
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3494
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3495
                VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv, vmask);
3496

3497
                // Check results as part of computation.
3498
                for (int j = 0; j < SPECIES.length(); j++) {
3499
                    Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
3500
                }
3501
            }
3502
        }
3503
    }
3504

3505

3506
    @Test(dataProvider = "intCompareOpProvider")
3507
    static void NEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3508
        int[] a = fa.apply(SPECIES.length());
3509
        int[] b = fb.apply(SPECIES.length());
3510

3511
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3512
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3513
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3514
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3515
                VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv);
3516

3517
                // Check results as part of computation.
3518
                for (int j = 0; j < SPECIES.length(); j++) {
3519
                    Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
3520
                }
3521
            }
3522
        }
3523
    }
3524

3525
    @Test(dataProvider = "intCompareOpMaskProvider")
3526
    static void NEInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3527
                                                IntFunction<boolean[]> fm) {
3528
        int[] a = fa.apply(SPECIES.length());
3529
        int[] b = fb.apply(SPECIES.length());
3530
        boolean[] mask = fm.apply(SPECIES.length());
3531

3532
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3533

3534
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3535
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3536
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3537
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3538
                VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv, vmask);
3539

3540
                // Check results as part of computation.
3541
                for (int j = 0; j < SPECIES.length(); j++) {
3542
                    Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
3543
                }
3544
            }
3545
        }
3546
    }
3547

3548

3549
    @Test(dataProvider = "intCompareOpProvider")
3550
    static void LEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3551
        int[] a = fa.apply(SPECIES.length());
3552
        int[] b = fb.apply(SPECIES.length());
3553

3554
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3555
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3556
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3557
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3558
                VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv);
3559

3560
                // Check results as part of computation.
3561
                for (int j = 0; j < SPECIES.length(); j++) {
3562
                    Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
3563
                }
3564
            }
3565
        }
3566
    }
3567

3568
    @Test(dataProvider = "intCompareOpMaskProvider")
3569
    static void LEInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3570
                                                IntFunction<boolean[]> fm) {
3571
        int[] a = fa.apply(SPECIES.length());
3572
        int[] b = fb.apply(SPECIES.length());
3573
        boolean[] mask = fm.apply(SPECIES.length());
3574

3575
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3576

3577
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3578
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3579
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3580
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3581
                VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv, vmask);
3582

3583
                // Check results as part of computation.
3584
                for (int j = 0; j < SPECIES.length(); j++) {
3585
                    Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
3586
                }
3587
            }
3588
        }
3589
    }
3590

3591

3592
    @Test(dataProvider = "intCompareOpProvider")
3593
    static void GEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3594
        int[] a = fa.apply(SPECIES.length());
3595
        int[] b = fb.apply(SPECIES.length());
3596

3597
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3598
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3599
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3600
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3601
                VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv);
3602

3603
                // Check results as part of computation.
3604
                for (int j = 0; j < SPECIES.length(); j++) {
3605
                    Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
3606
                }
3607
            }
3608
        }
3609
    }
3610

3611
    @Test(dataProvider = "intCompareOpMaskProvider")
3612
    static void GEInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3613
                                                IntFunction<boolean[]> fm) {
3614
        int[] a = fa.apply(SPECIES.length());
3615
        int[] b = fb.apply(SPECIES.length());
3616
        boolean[] mask = fm.apply(SPECIES.length());
3617

3618
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3619

3620
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3621
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3622
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3623
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3624
                VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv, vmask);
3625

3626
                // Check results as part of computation.
3627
                for (int j = 0; j < SPECIES.length(); j++) {
3628
                    Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
3629
                }
3630
            }
3631
        }
3632
    }
3633

3634

3635

3636
    @Test(dataProvider = "intCompareOpProvider")
3637
    static void UNSIGNED_LTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3638
        int[] a = fa.apply(SPECIES.length());
3639
        int[] b = fb.apply(SPECIES.length());
3640

3641
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3642
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3643
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3644
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3645
                VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LT, bv);
3646

3647
                // Check results as part of computation.
3648
                for (int j = 0; j < SPECIES.length(); j++) {
3649
                    Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
3650
                }
3651
            }
3652
        }
3653
    }
3654

3655

3656

3657
    @Test(dataProvider = "intCompareOpMaskProvider")
3658
    static void UNSIGNED_LTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3659
                                                IntFunction<boolean[]> fm) {
3660
        int[] a = fa.apply(SPECIES.length());
3661
        int[] b = fb.apply(SPECIES.length());
3662
        boolean[] mask = fm.apply(SPECIES.length());
3663

3664
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3665

3666
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3667
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3668
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3669
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3670
                VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LT, bv, vmask);
3671

3672
                // Check results as part of computation.
3673
                for (int j = 0; j < SPECIES.length(); j++) {
3674
                    Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
3675
                }
3676
            }
3677
        }
3678
    }
3679

3680

3681

3682

3683
    @Test(dataProvider = "intCompareOpProvider")
3684
    static void UNSIGNED_GTInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3685
        int[] a = fa.apply(SPECIES.length());
3686
        int[] b = fb.apply(SPECIES.length());
3687

3688
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3689
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3690
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3691
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3692
                VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GT, bv);
3693

3694
                // Check results as part of computation.
3695
                for (int j = 0; j < SPECIES.length(); j++) {
3696
                    Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
3697
                }
3698
            }
3699
        }
3700
    }
3701

3702

3703

3704
    @Test(dataProvider = "intCompareOpMaskProvider")
3705
    static void UNSIGNED_GTInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3706
                                                IntFunction<boolean[]> fm) {
3707
        int[] a = fa.apply(SPECIES.length());
3708
        int[] b = fb.apply(SPECIES.length());
3709
        boolean[] mask = fm.apply(SPECIES.length());
3710

3711
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3712

3713
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3714
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3715
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3716
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3717
                VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GT, bv, vmask);
3718

3719
                // Check results as part of computation.
3720
                for (int j = 0; j < SPECIES.length(); j++) {
3721
                    Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
3722
                }
3723
            }
3724
        }
3725
    }
3726

3727

3728

3729

3730
    @Test(dataProvider = "intCompareOpProvider")
3731
    static void UNSIGNED_LEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3732
        int[] a = fa.apply(SPECIES.length());
3733
        int[] b = fb.apply(SPECIES.length());
3734

3735
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3736
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3737
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3738
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3739
                VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LE, bv);
3740

3741
                // Check results as part of computation.
3742
                for (int j = 0; j < SPECIES.length(); j++) {
3743
                    Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
3744
                }
3745
            }
3746
        }
3747
    }
3748

3749

3750

3751
    @Test(dataProvider = "intCompareOpMaskProvider")
3752
    static void UNSIGNED_LEInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3753
                                                IntFunction<boolean[]> fm) {
3754
        int[] a = fa.apply(SPECIES.length());
3755
        int[] b = fb.apply(SPECIES.length());
3756
        boolean[] mask = fm.apply(SPECIES.length());
3757

3758
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3759

3760
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3761
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3762
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3763
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3764
                VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_LE, bv, vmask);
3765

3766
                // Check results as part of computation.
3767
                for (int j = 0; j < SPECIES.length(); j++) {
3768
                    Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j]));
3769
                }
3770
            }
3771
        }
3772
    }
3773

3774

3775

3776

3777
    @Test(dataProvider = "intCompareOpProvider")
3778
    static void UNSIGNED_GEInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3779
        int[] a = fa.apply(SPECIES.length());
3780
        int[] b = fb.apply(SPECIES.length());
3781

3782
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3783
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3784
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3785
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3786
                VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GE, bv);
3787

3788
                // Check results as part of computation.
3789
                for (int j = 0; j < SPECIES.length(); j++) {
3790
                    Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
3791
                }
3792
            }
3793
        }
3794
    }
3795

3796

3797

3798
    @Test(dataProvider = "intCompareOpMaskProvider")
3799
    static void UNSIGNED_GEInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3800
                                                IntFunction<boolean[]> fm) {
3801
        int[] a = fa.apply(SPECIES.length());
3802
        int[] b = fb.apply(SPECIES.length());
3803
        boolean[] mask = fm.apply(SPECIES.length());
3804

3805
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3806

3807
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3808
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3809
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3810
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3811
                VectorMask<Integer> mv = av.compare(VectorOperators.UNSIGNED_GE, bv, vmask);
3812

3813
                // Check results as part of computation.
3814
                for (int j = 0; j < SPECIES.length(); j++) {
3815
                    Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
3816
                }
3817
            }
3818
        }
3819
    }
3820

3821

3822

3823
    @Test(dataProvider = "intCompareOpProvider")
3824
    static void LTInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3825
        int[] a = fa.apply(SPECIES.length());
3826
        int[] b = fb.apply(SPECIES.length());
3827

3828
        for (int i = 0; i < a.length; i += SPECIES.length()) {
3829
            IntVector av = IntVector.fromArray(SPECIES, a, i);
3830
            VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i]);
3831

3832
            // Check results as part of computation.
3833
            for (int j = 0; j < SPECIES.length(); j++) {
3834
                Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
3835
            }
3836
        }
3837
    }
3838

3839

3840
    @Test(dataProvider = "intCompareOpMaskProvider")
3841
    static void LTInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa,
3842
                                IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
3843
        int[] a = fa.apply(SPECIES.length());
3844
        int[] b = fb.apply(SPECIES.length());
3845
        boolean[] mask = fm.apply(SPECIES.length());
3846

3847
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3848

3849
        for (int i = 0; i < a.length; i += SPECIES.length()) {
3850
            IntVector av = IntVector.fromArray(SPECIES, a, i);
3851
            VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i], vmask);
3852

3853
            // Check results as part of computation.
3854
            for (int j = 0; j < SPECIES.length(); j++) {
3855
                Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
3856
            }
3857
        }
3858
    }
3859

3860
    @Test(dataProvider = "intCompareOpProvider")
3861
    static void LTInt128VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3862
        int[] a = fa.apply(SPECIES.length());
3863
        int[] b = fb.apply(SPECIES.length());
3864

3865
        for (int i = 0; i < a.length; i += SPECIES.length()) {
3866
            IntVector av = IntVector.fromArray(SPECIES, a, i);
3867
            VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i]);
3868

3869
            // Check results as part of computation.
3870
            for (int j = 0; j < SPECIES.length(); j++) {
3871
                Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (int)((long)b[i]));
3872
            }
3873
        }
3874
    }
3875

3876

3877
    @Test(dataProvider = "intCompareOpMaskProvider")
3878
    static void LTInt128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa,
3879
                                IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
3880
        int[] a = fa.apply(SPECIES.length());
3881
        int[] b = fb.apply(SPECIES.length());
3882
        boolean[] mask = fm.apply(SPECIES.length());
3883

3884
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3885

3886
        for (int i = 0; i < a.length; i += SPECIES.length()) {
3887
            IntVector av = IntVector.fromArray(SPECIES, a, i);
3888
            VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
3889

3890
            // Check results as part of computation.
3891
            for (int j = 0; j < SPECIES.length(); j++) {
3892
                Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (int)((long)b[i])));
3893
            }
3894
        }
3895
    }
3896

3897
    @Test(dataProvider = "intCompareOpProvider")
3898
    static void EQInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3899
        int[] a = fa.apply(SPECIES.length());
3900
        int[] b = fb.apply(SPECIES.length());
3901

3902
        for (int i = 0; i < a.length; i += SPECIES.length()) {
3903
            IntVector av = IntVector.fromArray(SPECIES, a, i);
3904
            VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i]);
3905

3906
            // Check results as part of computation.
3907
            for (int j = 0; j < SPECIES.length(); j++) {
3908
                Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
3909
            }
3910
        }
3911
    }
3912

3913

3914
    @Test(dataProvider = "intCompareOpMaskProvider")
3915
    static void EQInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa,
3916
                                IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
3917
        int[] a = fa.apply(SPECIES.length());
3918
        int[] b = fb.apply(SPECIES.length());
3919
        boolean[] mask = fm.apply(SPECIES.length());
3920

3921
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3922

3923
        for (int i = 0; i < a.length; i += SPECIES.length()) {
3924
            IntVector av = IntVector.fromArray(SPECIES, a, i);
3925
            VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i], vmask);
3926

3927
            // Check results as part of computation.
3928
            for (int j = 0; j < SPECIES.length(); j++) {
3929
                Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
3930
            }
3931
        }
3932
    }
3933

3934
    @Test(dataProvider = "intCompareOpProvider")
3935
    static void EQInt128VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3936
        int[] a = fa.apply(SPECIES.length());
3937
        int[] b = fb.apply(SPECIES.length());
3938

3939
        for (int i = 0; i < a.length; i += SPECIES.length()) {
3940
            IntVector av = IntVector.fromArray(SPECIES, a, i);
3941
            VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i]);
3942

3943
            // Check results as part of computation.
3944
            for (int j = 0; j < SPECIES.length(); j++) {
3945
                Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (int)((long)b[i]));
3946
            }
3947
        }
3948
    }
3949

3950

3951
    @Test(dataProvider = "intCompareOpMaskProvider")
3952
    static void EQInt128VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa,
3953
                                IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
3954
        int[] a = fa.apply(SPECIES.length());
3955
        int[] b = fb.apply(SPECIES.length());
3956
        boolean[] mask = fm.apply(SPECIES.length());
3957

3958
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3959

3960
        for (int i = 0; i < a.length; i += SPECIES.length()) {
3961
            IntVector av = IntVector.fromArray(SPECIES, a, i);
3962
            VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
3963

3964
            // Check results as part of computation.
3965
            for (int j = 0; j < SPECIES.length(); j++) {
3966
                Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (int)((long)b[i])));
3967
            }
3968
        }
3969
    }
3970

3971
    static int blend(int a, int b, boolean mask) {
3972
        return mask ? b : a;
3973
    }
3974

3975
    @Test(dataProvider = "intBinaryOpMaskProvider")
3976
    static void blendInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
3977
                                          IntFunction<boolean[]> fm) {
3978
        int[] a = fa.apply(SPECIES.length());
3979
        int[] b = fb.apply(SPECIES.length());
3980
        int[] r = fr.apply(SPECIES.length());
3981
        boolean[] mask = fm.apply(SPECIES.length());
3982
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3983

3984
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
3985
            for (int i = 0; i < a.length; i += SPECIES.length()) {
3986
                IntVector av = IntVector.fromArray(SPECIES, a, i);
3987
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
3988
                av.blend(bv, vmask).intoArray(r, i);
3989
            }
3990
        }
3991

3992
        assertArraysEquals(r, a, b, mask, Int128VectorTests::blend);
3993
    }
3994

3995
    @Test(dataProvider = "intUnaryOpShuffleProvider")
3996
    static void RearrangeInt128VectorTests(IntFunction<int[]> fa,
3997
                                           BiFunction<Integer,Integer,int[]> fs) {
3998
        int[] a = fa.apply(SPECIES.length());
3999
        int[] order = fs.apply(a.length, SPECIES.length());
4000
        int[] r = fr.apply(SPECIES.length());
4001

4002
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4003
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4004
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4005
                av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
4006
            }
4007
        }
4008

4009
        assertRearrangeArraysEquals(r, a, order, SPECIES.length());
4010
    }
4011

4012
    @Test(dataProvider = "intUnaryOpShuffleMaskProvider")
4013
    static void RearrangeInt128VectorTestsMaskedSmokeTest(IntFunction<int[]> fa,
4014
                                                          BiFunction<Integer,Integer,int[]> fs,
4015
                                                          IntFunction<boolean[]> fm) {
4016
        int[] a = fa.apply(SPECIES.length());
4017
        int[] order = fs.apply(a.length, SPECIES.length());
4018
        int[] r = fr.apply(SPECIES.length());
4019
        boolean[] mask = fm.apply(SPECIES.length());
4020
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4021

4022
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4023
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4024
            av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
4025
        }
4026

4027
        assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
4028
    }
4029
    @Test(dataProvider = "intUnaryOpProvider")
4030
    static void getInt128VectorTests(IntFunction<int[]> fa) {
4031
        int[] a = fa.apply(SPECIES.length());
4032
        int[] r = fr.apply(SPECIES.length());
4033

4034
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4035
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4036
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4037
                int num_lanes = SPECIES.length();
4038
                // Manually unroll because full unroll happens after intrinsification.
4039
                // Unroll is needed because get intrinsic requires for index to be a known constant.
4040
                if (num_lanes == 1) {
4041
                    r[i]=av.lane(0);
4042
                } else if (num_lanes == 2) {
4043
                    r[i]=av.lane(0);
4044
                    r[i+1]=av.lane(1);
4045
                } else if (num_lanes == 4) {
4046
                    r[i]=av.lane(0);
4047
                    r[i+1]=av.lane(1);
4048
                    r[i+2]=av.lane(2);
4049
                    r[i+3]=av.lane(3);
4050
                } else if (num_lanes == 8) {
4051
                    r[i]=av.lane(0);
4052
                    r[i+1]=av.lane(1);
4053
                    r[i+2]=av.lane(2);
4054
                    r[i+3]=av.lane(3);
4055
                    r[i+4]=av.lane(4);
4056
                    r[i+5]=av.lane(5);
4057
                    r[i+6]=av.lane(6);
4058
                    r[i+7]=av.lane(7);
4059
                } else if (num_lanes == 16) {
4060
                    r[i]=av.lane(0);
4061
                    r[i+1]=av.lane(1);
4062
                    r[i+2]=av.lane(2);
4063
                    r[i+3]=av.lane(3);
4064
                    r[i+4]=av.lane(4);
4065
                    r[i+5]=av.lane(5);
4066
                    r[i+6]=av.lane(6);
4067
                    r[i+7]=av.lane(7);
4068
                    r[i+8]=av.lane(8);
4069
                    r[i+9]=av.lane(9);
4070
                    r[i+10]=av.lane(10);
4071
                    r[i+11]=av.lane(11);
4072
                    r[i+12]=av.lane(12);
4073
                    r[i+13]=av.lane(13);
4074
                    r[i+14]=av.lane(14);
4075
                    r[i+15]=av.lane(15);
4076
                } else if (num_lanes == 32) {
4077
                    r[i]=av.lane(0);
4078
                    r[i+1]=av.lane(1);
4079
                    r[i+2]=av.lane(2);
4080
                    r[i+3]=av.lane(3);
4081
                    r[i+4]=av.lane(4);
4082
                    r[i+5]=av.lane(5);
4083
                    r[i+6]=av.lane(6);
4084
                    r[i+7]=av.lane(7);
4085
                    r[i+8]=av.lane(8);
4086
                    r[i+9]=av.lane(9);
4087
                    r[i+10]=av.lane(10);
4088
                    r[i+11]=av.lane(11);
4089
                    r[i+12]=av.lane(12);
4090
                    r[i+13]=av.lane(13);
4091
                    r[i+14]=av.lane(14);
4092
                    r[i+15]=av.lane(15);
4093
                    r[i+16]=av.lane(16);
4094
                    r[i+17]=av.lane(17);
4095
                    r[i+18]=av.lane(18);
4096
                    r[i+19]=av.lane(19);
4097
                    r[i+20]=av.lane(20);
4098
                    r[i+21]=av.lane(21);
4099
                    r[i+22]=av.lane(22);
4100
                    r[i+23]=av.lane(23);
4101
                    r[i+24]=av.lane(24);
4102
                    r[i+25]=av.lane(25);
4103
                    r[i+26]=av.lane(26);
4104
                    r[i+27]=av.lane(27);
4105
                    r[i+28]=av.lane(28);
4106
                    r[i+29]=av.lane(29);
4107
                    r[i+30]=av.lane(30);
4108
                    r[i+31]=av.lane(31);
4109
                } else if (num_lanes == 64) {
4110
                    r[i]=av.lane(0);
4111
                    r[i+1]=av.lane(1);
4112
                    r[i+2]=av.lane(2);
4113
                    r[i+3]=av.lane(3);
4114
                    r[i+4]=av.lane(4);
4115
                    r[i+5]=av.lane(5);
4116
                    r[i+6]=av.lane(6);
4117
                    r[i+7]=av.lane(7);
4118
                    r[i+8]=av.lane(8);
4119
                    r[i+9]=av.lane(9);
4120
                    r[i+10]=av.lane(10);
4121
                    r[i+11]=av.lane(11);
4122
                    r[i+12]=av.lane(12);
4123
                    r[i+13]=av.lane(13);
4124
                    r[i+14]=av.lane(14);
4125
                    r[i+15]=av.lane(15);
4126
                    r[i+16]=av.lane(16);
4127
                    r[i+17]=av.lane(17);
4128
                    r[i+18]=av.lane(18);
4129
                    r[i+19]=av.lane(19);
4130
                    r[i+20]=av.lane(20);
4131
                    r[i+21]=av.lane(21);
4132
                    r[i+22]=av.lane(22);
4133
                    r[i+23]=av.lane(23);
4134
                    r[i+24]=av.lane(24);
4135
                    r[i+25]=av.lane(25);
4136
                    r[i+26]=av.lane(26);
4137
                    r[i+27]=av.lane(27);
4138
                    r[i+28]=av.lane(28);
4139
                    r[i+29]=av.lane(29);
4140
                    r[i+30]=av.lane(30);
4141
                    r[i+31]=av.lane(31);
4142
                    r[i+32]=av.lane(32);
4143
                    r[i+33]=av.lane(33);
4144
                    r[i+34]=av.lane(34);
4145
                    r[i+35]=av.lane(35);
4146
                    r[i+36]=av.lane(36);
4147
                    r[i+37]=av.lane(37);
4148
                    r[i+38]=av.lane(38);
4149
                    r[i+39]=av.lane(39);
4150
                    r[i+40]=av.lane(40);
4151
                    r[i+41]=av.lane(41);
4152
                    r[i+42]=av.lane(42);
4153
                    r[i+43]=av.lane(43);
4154
                    r[i+44]=av.lane(44);
4155
                    r[i+45]=av.lane(45);
4156
                    r[i+46]=av.lane(46);
4157
                    r[i+47]=av.lane(47);
4158
                    r[i+48]=av.lane(48);
4159
                    r[i+49]=av.lane(49);
4160
                    r[i+50]=av.lane(50);
4161
                    r[i+51]=av.lane(51);
4162
                    r[i+52]=av.lane(52);
4163
                    r[i+53]=av.lane(53);
4164
                    r[i+54]=av.lane(54);
4165
                    r[i+55]=av.lane(55);
4166
                    r[i+56]=av.lane(56);
4167
                    r[i+57]=av.lane(57);
4168
                    r[i+58]=av.lane(58);
4169
                    r[i+59]=av.lane(59);
4170
                    r[i+60]=av.lane(60);
4171
                    r[i+61]=av.lane(61);
4172
                    r[i+62]=av.lane(62);
4173
                    r[i+63]=av.lane(63);
4174
                } else {
4175
                    for (int j = 0; j < SPECIES.length(); j++) {
4176
                        r[i+j]=av.lane(j);
4177
                    }
4178
                }
4179
            }
4180
        }
4181

4182
        assertArraysEquals(r, a, Int128VectorTests::get);
4183
    }
4184

4185
    @Test(dataProvider = "intUnaryOpProvider")
4186
    static void BroadcastInt128VectorTests(IntFunction<int[]> fa) {
4187
        int[] a = fa.apply(SPECIES.length());
4188
        int[] r = new int[a.length];
4189

4190
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4191
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4192
                IntVector.broadcast(SPECIES, a[i]).intoArray(r, i);
4193
            }
4194
        }
4195

4196
        assertBroadcastArraysEquals(r, a);
4197
    }
4198

4199

4200

4201

4202

4203
    @Test(dataProvider = "intUnaryOpProvider")
4204
    static void ZeroInt128VectorTests(IntFunction<int[]> fa) {
4205
        int[] a = fa.apply(SPECIES.length());
4206
        int[] r = new int[a.length];
4207

4208
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4209
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4210
                IntVector.zero(SPECIES).intoArray(a, i);
4211
            }
4212
        }
4213

4214
        Assert.assertEquals(a, r);
4215
    }
4216

4217

4218

4219

4220
    static int[] sliceUnary(int[] a, int origin, int idx) {
4221
        int[] res = new int[SPECIES.length()];
4222
        for (int i = 0; i < SPECIES.length(); i++){
4223
            if(i+origin < SPECIES.length())
4224
                res[i] = a[idx+i+origin];
4225
            else
4226
                res[i] = (int)0;
4227
        }
4228
        return res;
4229
    }
4230

4231
    @Test(dataProvider = "intUnaryOpProvider")
4232
    static void sliceUnaryInt128VectorTests(IntFunction<int[]> fa) {
4233
        int[] a = fa.apply(SPECIES.length());
4234
        int[] r = new int[a.length];
4235
        int origin = (new java.util.Random()).nextInt(SPECIES.length());
4236
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4237
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4238
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4239
                av.slice(origin).intoArray(r, i);
4240
            }
4241
        }
4242

4243
        assertArraysEquals(r, a, origin, Int128VectorTests::sliceUnary);
4244
    }
4245
    static int[] sliceBinary(int[] a, int[] b, int origin, int idx) {
4246
        int[] res = new int[SPECIES.length()];
4247
        for (int i = 0, j = 0; i < SPECIES.length(); i++){
4248
            if(i+origin < SPECIES.length())
4249
                res[i] = a[idx+i+origin];
4250
            else {
4251
                res[i] = b[idx+j];
4252
                j++;
4253
            }
4254
        }
4255
        return res;
4256
    }
4257

4258
    @Test(dataProvider = "intBinaryOpProvider")
4259
    static void sliceBinaryInt128VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4260
        int[] a = fa.apply(SPECIES.length());
4261
        int[] b = fb.apply(SPECIES.length());
4262
        int[] r = new int[a.length];
4263
        int origin = (new java.util.Random()).nextInt(SPECIES.length());
4264
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4265
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4266
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4267
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
4268
                av.slice(origin, bv).intoArray(r, i);
4269
            }
4270
        }
4271

4272
        assertArraysEquals(r, a, b, origin, Int128VectorTests::sliceBinary);
4273
    }
4274
    static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) {
4275
        int[] res = new int[SPECIES.length()];
4276
        for (int i = 0, j = 0; i < SPECIES.length(); i++){
4277
            if(i+origin < SPECIES.length())
4278
                res[i] = mask[i] ? a[idx+i+origin] : (int)0;
4279
            else {
4280
                res[i] = mask[i] ? b[idx+j] : (int)0;
4281
                j++;
4282
            }
4283
        }
4284
        return res;
4285
    }
4286

4287
    @Test(dataProvider = "intBinaryOpMaskProvider")
4288
    static void sliceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4289
    IntFunction<boolean[]> fm) {
4290
        int[] a = fa.apply(SPECIES.length());
4291
        int[] b = fb.apply(SPECIES.length());
4292
        boolean[] mask = fm.apply(SPECIES.length());
4293
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4294

4295
        int[] r = new int[a.length];
4296
        int origin = (new java.util.Random()).nextInt(SPECIES.length());
4297
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4298
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4299
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4300
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
4301
                av.slice(origin, bv, vmask).intoArray(r, i);
4302
            }
4303
        }
4304

4305
        assertArraysEquals(r, a, b, origin, mask, Int128VectorTests::slice);
4306
    }
4307
    static int[] unsliceUnary(int[] a, int origin, int idx) {
4308
        int[] res = new int[SPECIES.length()];
4309
        for (int i = 0, j = 0; i < SPECIES.length(); i++){
4310
            if(i < origin)
4311
                res[i] = (int)0;
4312
            else {
4313
                res[i] = a[idx+j];
4314
                j++;
4315
            }
4316
        }
4317
        return res;
4318
    }
4319

4320
    @Test(dataProvider = "intUnaryOpProvider")
4321
    static void unsliceUnaryInt128VectorTests(IntFunction<int[]> fa) {
4322
        int[] a = fa.apply(SPECIES.length());
4323
        int[] r = new int[a.length];
4324
        int origin = (new java.util.Random()).nextInt(SPECIES.length());
4325
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4326
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4327
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4328
                av.unslice(origin).intoArray(r, i);
4329
            }
4330
        }
4331

4332
        assertArraysEquals(r, a, origin, Int128VectorTests::unsliceUnary);
4333
    }
4334
    static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) {
4335
        int[] res = new int[SPECIES.length()];
4336
        for (int i = 0, j = 0; i < SPECIES.length(); i++){
4337
            if (part == 0) {
4338
                if (i < origin)
4339
                    res[i] = b[idx+i];
4340
                else {
4341
                    res[i] = a[idx+j];
4342
                    j++;
4343
                }
4344
            } else if (part == 1) {
4345
                if (i < origin)
4346
                    res[i] = a[idx+SPECIES.length()-origin+i];
4347
                else {
4348
                    res[i] = b[idx+origin+j];
4349
                    j++;
4350
                }
4351
            }
4352
        }
4353
        return res;
4354
    }
4355

4356
    @Test(dataProvider = "intBinaryOpProvider")
4357
    static void unsliceBinaryInt128VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4358
        int[] a = fa.apply(SPECIES.length());
4359
        int[] b = fb.apply(SPECIES.length());
4360
        int[] r = new int[a.length];
4361
        int origin = (new java.util.Random()).nextInt(SPECIES.length());
4362
        int part = (new java.util.Random()).nextInt(2);
4363
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4364
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4365
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4366
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
4367
                av.unslice(origin, bv, part).intoArray(r, i);
4368
            }
4369
        }
4370

4371
        assertArraysEquals(r, a, b, origin, part, Int128VectorTests::unsliceBinary);
4372
    }
4373
    static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) {
4374
        int[] res = new int[SPECIES.length()];
4375
        for (int i = 0, j = 0; i < SPECIES.length(); i++){
4376
            if(i+origin < SPECIES.length())
4377
                res[i] = b[idx+i+origin];
4378
            else {
4379
                res[i] = b[idx+j];
4380
                j++;
4381
            }
4382
        }
4383
        for (int i = 0; i < SPECIES.length(); i++){
4384
            res[i] = mask[i] ? a[idx+i] : res[i];
4385
        }
4386
        int[] res1 = new int[SPECIES.length()];
4387
        if (part == 0) {
4388
            for (int i = 0, j = 0; i < SPECIES.length(); i++){
4389
                if (i < origin)
4390
                    res1[i] = b[idx+i];
4391
                else {
4392
                   res1[i] = res[j];
4393
                   j++;
4394
                }
4395
            }
4396
        } else if (part == 1) {
4397
            for (int i = 0, j = 0; i < SPECIES.length(); i++){
4398
                if (i < origin)
4399
                    res1[i] = res[SPECIES.length()-origin+i];
4400
                else {
4401
                    res1[i] = b[idx+origin+j];
4402
                    j++;
4403
                }
4404
            }
4405
        }
4406
        return res1;
4407
    }
4408

4409
    @Test(dataProvider = "intBinaryOpMaskProvider")
4410
    static void unsliceInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4411
    IntFunction<boolean[]> fm) {
4412
        int[] a = fa.apply(SPECIES.length());
4413
        int[] b = fb.apply(SPECIES.length());
4414
        boolean[] mask = fm.apply(SPECIES.length());
4415
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4416
        int[] r = new int[a.length];
4417
        int origin = (new java.util.Random()).nextInt(SPECIES.length());
4418
        int part = (new java.util.Random()).nextInt(2);
4419
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4420
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4421
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4422
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
4423
                av.unslice(origin, bv, part, vmask).intoArray(r, i);
4424
            }
4425
        }
4426

4427
        assertArraysEquals(r, a, b, origin, part, mask, Int128VectorTests::unslice);
4428
    }
4429

4430

4431

4432

4433

4434

4435

4436

4437

4438

4439

4440

4441

4442

4443

4444

4445

4446

4447

4448

4449

4450

4451

4452
    static int BITWISE_BLEND(int a, int b, int c) {
4453
        return (int)((a&~(c))|(b&c));
4454
    }
4455
    static int bitwiseBlend(int a, int b, int c) {
4456
        return (int)((a&~(c))|(b&c));
4457
    }
4458

4459

4460
    @Test(dataProvider = "intTernaryOpProvider")
4461
    static void BITWISE_BLENDInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
4462
        int[] a = fa.apply(SPECIES.length());
4463
        int[] b = fb.apply(SPECIES.length());
4464
        int[] c = fc.apply(SPECIES.length());
4465
        int[] r = fr.apply(SPECIES.length());
4466

4467
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4468
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4469
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4470
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
4471
                IntVector cv = IntVector.fromArray(SPECIES, c, i);
4472
                av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
4473
            }
4474
        }
4475

4476
        assertArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND);
4477
    }
4478
    @Test(dataProvider = "intTernaryOpProvider")
4479
    static void bitwiseBlendInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
4480
        int[] a = fa.apply(SPECIES.length());
4481
        int[] b = fb.apply(SPECIES.length());
4482
        int[] c = fc.apply(SPECIES.length());
4483
        int[] r = fr.apply(SPECIES.length());
4484

4485
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4486
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4487
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
4488
            IntVector cv = IntVector.fromArray(SPECIES, c, i);
4489
            av.bitwiseBlend(bv, cv).intoArray(r, i);
4490
        }
4491

4492
        assertArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend);
4493
    }
4494

4495

4496
    @Test(dataProvider = "intTernaryOpMaskProvider")
4497
    static void BITWISE_BLENDInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4498
                                          IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
4499
        int[] a = fa.apply(SPECIES.length());
4500
        int[] b = fb.apply(SPECIES.length());
4501
        int[] c = fc.apply(SPECIES.length());
4502
        int[] r = fr.apply(SPECIES.length());
4503
        boolean[] mask = fm.apply(SPECIES.length());
4504
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4505

4506
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4507
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4508
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4509
                IntVector bv = IntVector.fromArray(SPECIES, b, i);
4510
                IntVector cv = IntVector.fromArray(SPECIES, c, i);
4511
                av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
4512
            }
4513
        }
4514

4515
        assertArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND);
4516
    }
4517

4518

4519

4520

4521
    @Test(dataProvider = "intTernaryOpProvider")
4522
    static void BITWISE_BLENDInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
4523
        int[] a = fa.apply(SPECIES.length());
4524
        int[] b = fb.apply(SPECIES.length());
4525
        int[] c = fc.apply(SPECIES.length());
4526
        int[] r = fr.apply(SPECIES.length());
4527

4528
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4529
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4530
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
4531
            av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
4532
        }
4533
        assertBroadcastArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND);
4534
    }
4535

4536
    @Test(dataProvider = "intTernaryOpProvider")
4537
    static void BITWISE_BLENDInt128VectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
4538
        int[] a = fa.apply(SPECIES.length());
4539
        int[] b = fb.apply(SPECIES.length());
4540
        int[] c = fc.apply(SPECIES.length());
4541
        int[] r = fr.apply(SPECIES.length());
4542

4543
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4544
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4545
            IntVector cv = IntVector.fromArray(SPECIES, c, i);
4546
            av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
4547
        }
4548
        assertAltBroadcastArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND);
4549
    }
4550
    @Test(dataProvider = "intTernaryOpProvider")
4551
    static void bitwiseBlendInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
4552
        int[] a = fa.apply(SPECIES.length());
4553
        int[] b = fb.apply(SPECIES.length());
4554
        int[] c = fc.apply(SPECIES.length());
4555
        int[] r = fr.apply(SPECIES.length());
4556

4557
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4558
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4559
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
4560
            av.bitwiseBlend(bv, c[i]).intoArray(r, i);
4561
        }
4562
        assertBroadcastArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend);
4563
    }
4564

4565
    @Test(dataProvider = "intTernaryOpProvider")
4566
    static void bitwiseBlendInt128VectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
4567
        int[] a = fa.apply(SPECIES.length());
4568
        int[] b = fb.apply(SPECIES.length());
4569
        int[] c = fc.apply(SPECIES.length());
4570
        int[] r = fr.apply(SPECIES.length());
4571

4572
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4573
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4574
            IntVector cv = IntVector.fromArray(SPECIES, c, i);
4575
            av.bitwiseBlend(b[i], cv).intoArray(r, i);
4576
        }
4577
        assertAltBroadcastArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend);
4578
    }
4579

4580

4581
    @Test(dataProvider = "intTernaryOpMaskProvider")
4582
    static void BITWISE_BLENDInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
4583
                                          IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
4584
        int[] a = fa.apply(SPECIES.length());
4585
        int[] b = fb.apply(SPECIES.length());
4586
        int[] c = fc.apply(SPECIES.length());
4587
        int[] r = fr.apply(SPECIES.length());
4588
        boolean[] mask = fm.apply(SPECIES.length());
4589
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4590

4591
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4592
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4593
            IntVector bv = IntVector.fromArray(SPECIES, b, i);
4594
            av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
4595
        }
4596

4597
        assertBroadcastArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND);
4598
    }
4599

4600
    @Test(dataProvider = "intTernaryOpMaskProvider")
4601
    static void BITWISE_BLENDInt128VectorTestsAltBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
4602
                                          IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
4603
        int[] a = fa.apply(SPECIES.length());
4604
        int[] b = fb.apply(SPECIES.length());
4605
        int[] c = fc.apply(SPECIES.length());
4606
        int[] r = fr.apply(SPECIES.length());
4607
        boolean[] mask = fm.apply(SPECIES.length());
4608
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4609

4610
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4611
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4612
            IntVector cv = IntVector.fromArray(SPECIES, c, i);
4613
            av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
4614
        }
4615

4616
        assertAltBroadcastArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND);
4617
    }
4618

4619

4620

4621

4622
    @Test(dataProvider = "intTernaryOpProvider")
4623
    static void BITWISE_BLENDInt128VectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
4624
        int[] a = fa.apply(SPECIES.length());
4625
        int[] b = fb.apply(SPECIES.length());
4626
        int[] c = fc.apply(SPECIES.length());
4627
        int[] r = fr.apply(SPECIES.length());
4628

4629
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4630
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4631
            av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
4632
        }
4633

4634
        assertDoubleBroadcastArraysEquals(r, a, b, c, Int128VectorTests::BITWISE_BLEND);
4635
    }
4636
    @Test(dataProvider = "intTernaryOpProvider")
4637
    static void bitwiseBlendInt128VectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
4638
        int[] a = fa.apply(SPECIES.length());
4639
        int[] b = fb.apply(SPECIES.length());
4640
        int[] c = fc.apply(SPECIES.length());
4641
        int[] r = fr.apply(SPECIES.length());
4642

4643
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4644
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4645
            av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
4646
        }
4647

4648
        assertDoubleBroadcastArraysEquals(r, a, b, c, Int128VectorTests::bitwiseBlend);
4649
    }
4650

4651

4652
    @Test(dataProvider = "intTernaryOpMaskProvider")
4653
    static void BITWISE_BLENDInt128VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
4654
                                          IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
4655
        int[] a = fa.apply(SPECIES.length());
4656
        int[] b = fb.apply(SPECIES.length());
4657
        int[] c = fc.apply(SPECIES.length());
4658
        int[] r = fr.apply(SPECIES.length());
4659
        boolean[] mask = fm.apply(SPECIES.length());
4660
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4661

4662
        for (int i = 0; i < a.length; i += SPECIES.length()) {
4663
            IntVector av = IntVector.fromArray(SPECIES, a, i);
4664
            av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
4665
        }
4666

4667
        assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Int128VectorTests::BITWISE_BLEND);
4668
    }
4669

4670

4671
    static int NEG(int a) {
4672
        return (int)(-((int)a));
4673
    }
4674

4675
    static int neg(int a) {
4676
        return (int)(-((int)a));
4677
    }
4678

4679
    @Test(dataProvider = "intUnaryOpProvider")
4680
    static void NEGInt128VectorTests(IntFunction<int[]> fa) {
4681
        int[] a = fa.apply(SPECIES.length());
4682
        int[] r = fr.apply(SPECIES.length());
4683

4684
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4685
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4686
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4687
                av.lanewise(VectorOperators.NEG).intoArray(r, i);
4688
            }
4689
        }
4690

4691
        assertArraysEquals(r, a, Int128VectorTests::NEG);
4692
    }
4693

4694
    @Test(dataProvider = "intUnaryOpProvider")
4695
    static void negInt128VectorTests(IntFunction<int[]> fa) {
4696
        int[] a = fa.apply(SPECIES.length());
4697
        int[] r = fr.apply(SPECIES.length());
4698

4699
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4700
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4701
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4702
                av.neg().intoArray(r, i);
4703
            }
4704
        }
4705

4706
        assertArraysEquals(r, a, Int128VectorTests::neg);
4707
    }
4708

4709
    @Test(dataProvider = "intUnaryOpMaskProvider")
4710
    static void NEGMaskedInt128VectorTests(IntFunction<int[]> fa,
4711
                                                IntFunction<boolean[]> fm) {
4712
        int[] a = fa.apply(SPECIES.length());
4713
        int[] r = fr.apply(SPECIES.length());
4714
        boolean[] mask = fm.apply(SPECIES.length());
4715
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4716

4717
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4718
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4719
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4720
                av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
4721
            }
4722
        }
4723

4724
        assertArraysEquals(r, a, mask, Int128VectorTests::NEG);
4725
    }
4726

4727
    static int ABS(int a) {
4728
        return (int)(Math.abs((int)a));
4729
    }
4730

4731
    static int abs(int a) {
4732
        return (int)(Math.abs((int)a));
4733
    }
4734

4735
    @Test(dataProvider = "intUnaryOpProvider")
4736
    static void ABSInt128VectorTests(IntFunction<int[]> fa) {
4737
        int[] a = fa.apply(SPECIES.length());
4738
        int[] r = fr.apply(SPECIES.length());
4739

4740
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4741
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4742
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4743
                av.lanewise(VectorOperators.ABS).intoArray(r, i);
4744
            }
4745
        }
4746

4747
        assertArraysEquals(r, a, Int128VectorTests::ABS);
4748
    }
4749

4750
    @Test(dataProvider = "intUnaryOpProvider")
4751
    static void absInt128VectorTests(IntFunction<int[]> fa) {
4752
        int[] a = fa.apply(SPECIES.length());
4753
        int[] r = fr.apply(SPECIES.length());
4754

4755
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4756
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4757
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4758
                av.abs().intoArray(r, i);
4759
            }
4760
        }
4761

4762
        assertArraysEquals(r, a, Int128VectorTests::abs);
4763
    }
4764

4765
    @Test(dataProvider = "intUnaryOpMaskProvider")
4766
    static void ABSMaskedInt128VectorTests(IntFunction<int[]> fa,
4767
                                                IntFunction<boolean[]> fm) {
4768
        int[] a = fa.apply(SPECIES.length());
4769
        int[] r = fr.apply(SPECIES.length());
4770
        boolean[] mask = fm.apply(SPECIES.length());
4771
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4772

4773
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4774
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4775
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4776
                av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
4777
            }
4778
        }
4779

4780
        assertArraysEquals(r, a, mask, Int128VectorTests::ABS);
4781
    }
4782

4783

4784
    static int NOT(int a) {
4785
        return (int)(~((int)a));
4786
    }
4787

4788
    static int not(int a) {
4789
        return (int)(~((int)a));
4790
    }
4791

4792

4793

4794
    @Test(dataProvider = "intUnaryOpProvider")
4795
    static void NOTInt128VectorTests(IntFunction<int[]> fa) {
4796
        int[] a = fa.apply(SPECIES.length());
4797
        int[] r = fr.apply(SPECIES.length());
4798

4799
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4800
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4801
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4802
                av.lanewise(VectorOperators.NOT).intoArray(r, i);
4803
            }
4804
        }
4805

4806
        assertArraysEquals(r, a, Int128VectorTests::NOT);
4807
    }
4808

4809
    @Test(dataProvider = "intUnaryOpProvider")
4810
    static void notInt128VectorTests(IntFunction<int[]> fa) {
4811
        int[] a = fa.apply(SPECIES.length());
4812
        int[] r = fr.apply(SPECIES.length());
4813

4814
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4815
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4816
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4817
                av.not().intoArray(r, i);
4818
            }
4819
        }
4820

4821
        assertArraysEquals(r, a, Int128VectorTests::not);
4822
    }
4823

4824

4825

4826
    @Test(dataProvider = "intUnaryOpMaskProvider")
4827
    static void NOTMaskedInt128VectorTests(IntFunction<int[]> fa,
4828
                                                IntFunction<boolean[]> fm) {
4829
        int[] a = fa.apply(SPECIES.length());
4830
        int[] r = fr.apply(SPECIES.length());
4831
        boolean[] mask = fm.apply(SPECIES.length());
4832
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4833

4834
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4835
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4836
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4837
                av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
4838
            }
4839
        }
4840

4841
        assertArraysEquals(r, a, mask, Int128VectorTests::NOT);
4842
    }
4843

4844

4845

4846
    static int ZOMO(int a) {
4847
        return (int)((a==0?0:-1));
4848
    }
4849

4850

4851

4852
    @Test(dataProvider = "intUnaryOpProvider")
4853
    static void ZOMOInt128VectorTests(IntFunction<int[]> fa) {
4854
        int[] a = fa.apply(SPECIES.length());
4855
        int[] r = fr.apply(SPECIES.length());
4856

4857
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4858
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4859
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4860
                av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
4861
            }
4862
        }
4863

4864
        assertArraysEquals(r, a, Int128VectorTests::ZOMO);
4865
    }
4866

4867

4868

4869
    @Test(dataProvider = "intUnaryOpMaskProvider")
4870
    static void ZOMOMaskedInt128VectorTests(IntFunction<int[]> fa,
4871
                                                IntFunction<boolean[]> fm) {
4872
        int[] a = fa.apply(SPECIES.length());
4873
        int[] r = fr.apply(SPECIES.length());
4874
        boolean[] mask = fm.apply(SPECIES.length());
4875
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4876

4877
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4878
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4879
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4880
                av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
4881
            }
4882
        }
4883

4884
        assertArraysEquals(r, a, mask, Int128VectorTests::ZOMO);
4885
    }
4886

4887

4888

4889

4890
    static int[] gather(int a[], int ix, int[] b, int iy) {
4891
        int[] res = new int[SPECIES.length()];
4892
        for (int i = 0; i < SPECIES.length(); i++) {
4893
            int bi = iy + i;
4894
            res[i] = a[b[bi] + ix];
4895
        }
4896
        return res;
4897
    }
4898

4899
    @Test(dataProvider = "intUnaryOpIndexProvider")
4900
    static void gatherInt128VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
4901
        int[] a = fa.apply(SPECIES.length());
4902
        int[] b    = fs.apply(a.length, SPECIES.length());
4903
        int[] r = new int[a.length];
4904

4905
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4906
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4907
                IntVector av = IntVector.fromArray(SPECIES, a, i, b, i);
4908
                av.intoArray(r, i);
4909
            }
4910
        }
4911

4912
        assertArraysEquals(r, a, b, Int128VectorTests::gather);
4913
    }
4914
    static int[] gatherMasked(int a[], int ix, boolean[] mask, int[] b, int iy) {
4915
        int[] res = new int[SPECIES.length()];
4916
        for (int i = 0; i < SPECIES.length(); i++) {
4917
            int bi = iy + i;
4918
            if (mask[i]) {
4919
              res[i] = a[b[bi] + ix];
4920
            }
4921
        }
4922
        return res;
4923
    }
4924

4925
    @Test(dataProvider = "intUnaryMaskedOpIndexProvider")
4926
    static void gatherMaskedInt128VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
4927
        int[] a = fa.apply(SPECIES.length());
4928
        int[] b    = fs.apply(a.length, SPECIES.length());
4929
        int[] r = new int[a.length];
4930
        boolean[] mask = fm.apply(SPECIES.length());
4931
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4932

4933
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4934
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4935
                IntVector av = IntVector.fromArray(SPECIES, a, i, b, i, vmask);
4936
                av.intoArray(r, i);
4937
            }
4938
        }
4939

4940
        assertArraysEquals(r, a, b, mask, Int128VectorTests::gatherMasked);
4941
    }
4942

4943
    static int[] scatter(int a[], int ix, int[] b, int iy) {
4944
      int[] res = new int[SPECIES.length()];
4945
      for (int i = 0; i < SPECIES.length(); i++) {
4946
        int bi = iy + i;
4947
        res[b[bi]] = a[i + ix];
4948
      }
4949
      return res;
4950
    }
4951

4952
    @Test(dataProvider = "intUnaryOpIndexProvider")
4953
    static void scatterInt128VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
4954
        int[] a = fa.apply(SPECIES.length());
4955
        int[] b = fs.apply(a.length, SPECIES.length());
4956
        int[] r = new int[a.length];
4957

4958
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4959
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4960
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4961
                av.intoArray(r, i, b, i);
4962
            }
4963
        }
4964

4965
        assertArraysEquals(r, a, b, Int128VectorTests::scatter);
4966
    }
4967

4968
    static int[] scatterMasked(int r[], int a[], int ix, boolean[] mask, int[] b, int iy) {
4969
      // First, gather r.
4970
      int[] oldVal = gather(r, ix, b, iy);
4971
      int[] newVal = new int[SPECIES.length()];
4972

4973
      // Second, blending it with a.
4974
      for (int i = 0; i < SPECIES.length(); i++) {
4975
        newVal[i] = blend(oldVal[i], a[i+ix], mask[i]);
4976
      }
4977

4978
      // Third, scatter: copy old value of r, and scatter it manually.
4979
      int[] res = Arrays.copyOfRange(r, ix, ix+SPECIES.length());
4980
      for (int i = 0; i < SPECIES.length(); i++) {
4981
        int bi = iy + i;
4982
        res[b[bi]] = newVal[i];
4983
      }
4984

4985
      return res;
4986
    }
4987

4988
    @Test(dataProvider = "scatterMaskedOpIndexProvider")
4989
    static void scatterMaskedInt128VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
4990
        int[] a = fa.apply(SPECIES.length());
4991
        int[] b = fs.apply(a.length, SPECIES.length());
4992
        int[] r = fb.apply(SPECIES.length());
4993
        boolean[] mask = fm.apply(SPECIES.length());
4994
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4995

4996
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
4997
            for (int i = 0; i < a.length; i += SPECIES.length()) {
4998
                IntVector av = IntVector.fromArray(SPECIES, a, i);
4999
                av.intoArray(r, i, b, i, vmask);
5000
            }
5001
        }
5002

5003
        assertArraysEquals(r, a, b, mask, Int128VectorTests::scatterMasked);
5004
    }
5005

5006

5007
    @Test(dataProvider = "intCompareOpProvider")
5008
    static void ltInt128VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5009
        int[] a = fa.apply(SPECIES.length());
5010
        int[] b = fb.apply(SPECIES.length());
5011

5012
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5013
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5014
            VectorMask<Integer> mv = av.lt(b[i]);
5015

5016
            // Check results as part of computation.
5017
            for (int j = 0; j < SPECIES.length(); j++) {
5018
                Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
5019
            }
5020
        }
5021
    }
5022

5023
    @Test(dataProvider = "intCompareOpProvider")
5024
    static void eqInt128VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5025
        int[] a = fa.apply(SPECIES.length());
5026
        int[] b = fb.apply(SPECIES.length());
5027

5028
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5029
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5030
            VectorMask<Integer> mv = av.eq(b[i]);
5031

5032
            // Check results as part of computation.
5033
            for (int j = 0; j < SPECIES.length(); j++) {
5034
                Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
5035
            }
5036
        }
5037
    }
5038

5039
    @Test(dataProvider = "intUnaryOpProvider")
5040
    static void toIntArrayInt128VectorTestsSmokeTest(IntFunction<int[]> fa) {
5041
        int[] a = fa.apply(SPECIES.length());
5042

5043
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5044
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5045
            int[] r = av.toIntArray();
5046
            assertArraysEquals(r, a, i);
5047
        }
5048
    }
5049

5050
    @Test(dataProvider = "intUnaryOpProvider")
5051
    static void toLongArrayInt128VectorTestsSmokeTest(IntFunction<int[]> fa) {
5052
        int[] a = fa.apply(SPECIES.length());
5053

5054
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5055
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5056
            long[] r = av.toLongArray();
5057
            assertArraysEquals(r, a, i);
5058
        }
5059
    }
5060

5061
    @Test(dataProvider = "intUnaryOpProvider")
5062
    static void toDoubleArrayInt128VectorTestsSmokeTest(IntFunction<int[]> fa) {
5063
        int[] a = fa.apply(SPECIES.length());
5064

5065
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5066
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5067
            double[] r = av.toDoubleArray();
5068
            assertArraysEquals(r, a, i);
5069
        }
5070
    }
5071

5072
    @Test(dataProvider = "intUnaryOpProvider")
5073
    static void toStringInt128VectorTestsSmokeTest(IntFunction<int[]> fa) {
5074
        int[] a = fa.apply(SPECIES.length());
5075

5076
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5077
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5078
            String str = av.toString();
5079

5080
            int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5081
            Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5082
        }
5083
    }
5084

5085
    @Test(dataProvider = "intUnaryOpProvider")
5086
    static void hashCodeInt128VectorTestsSmokeTest(IntFunction<int[]> fa) {
5087
        int[] a = fa.apply(SPECIES.length());
5088

5089
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5090
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5091
            int hash = av.hashCode();
5092

5093
            int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5094
            int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5095
            Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5096
        }
5097
    }
5098

5099

5100
    static long ADDReduceLong(int[] a, int idx) {
5101
        int res = 0;
5102
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
5103
            res += a[i];
5104
        }
5105

5106
        return (long)res;
5107
    }
5108

5109
    static long ADDReduceAllLong(int[] a) {
5110
        long res = 0;
5111
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5112
            res += ADDReduceLong(a, i);
5113
        }
5114

5115
        return res;
5116
    }
5117

5118
    @Test(dataProvider = "intUnaryOpProvider")
5119
    static void ADDReduceLongInt128VectorTests(IntFunction<int[]> fa) {
5120
        int[] a = fa.apply(SPECIES.length());
5121
        long[] r = lfr.apply(SPECIES.length());
5122
        long ra = 0;
5123

5124
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5125
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5126
            r[i] = av.reduceLanesToLong(VectorOperators.ADD);
5127
        }
5128

5129
        ra = 0;
5130
        for (int i = 0; i < a.length; i ++) {
5131
            ra += r[i];
5132
        }
5133

5134
        assertReductionLongArraysEquals(r, ra, a,
5135
                Int128VectorTests::ADDReduceLong, Int128VectorTests::ADDReduceAllLong);
5136
    }
5137

5138
    static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) {
5139
        int res = 0;
5140
        for (int i = idx; i < (idx + SPECIES.length()); i++) {
5141
            if(mask[i % SPECIES.length()])
5142
                res += a[i];
5143
        }
5144

5145
        return (long)res;
5146
    }
5147

5148
    static long ADDReduceAllLongMasked(int[] a, boolean[] mask) {
5149
        long res = 0;
5150
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5151
            res += ADDReduceLongMasked(a, i, mask);
5152
        }
5153

5154
        return res;
5155
    }
5156

5157
    @Test(dataProvider = "intUnaryOpMaskProvider")
5158
    static void ADDReduceLongInt128VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
5159
        int[] a = fa.apply(SPECIES.length());
5160
        long[] r = lfr.apply(SPECIES.length());
5161
        boolean[] mask = fm.apply(SPECIES.length());
5162
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5163
        long ra = 0;
5164

5165
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5166
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5167
            r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
5168
        }
5169

5170
        ra = 0;
5171
        for (int i = 0; i < a.length; i ++) {
5172
            ra += r[i];
5173
        }
5174

5175
        assertReductionLongArraysEqualsMasked(r, ra, a, mask,
5176
                Int128VectorTests::ADDReduceLongMasked, Int128VectorTests::ADDReduceAllLongMasked);
5177
    }
5178

5179
    @Test(dataProvider = "intUnaryOpProvider")
5180
    static void BroadcastLongInt128VectorTestsSmokeTest(IntFunction<int[]> fa) {
5181
        int[] a = fa.apply(SPECIES.length());
5182
        int[] r = new int[a.length];
5183

5184
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5185
            IntVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
5186
        }
5187
        assertBroadcastArraysEquals(r, a);
5188
    }
5189

5190
    @Test(dataProvider = "intBinaryOpMaskProvider")
5191
    static void blendInt128VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
5192
                                          IntFunction<boolean[]> fm) {
5193
        int[] a = fa.apply(SPECIES.length());
5194
        int[] b = fb.apply(SPECIES.length());
5195
        int[] r = fr.apply(SPECIES.length());
5196
        boolean[] mask = fm.apply(SPECIES.length());
5197
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5198

5199
        for (int ic = 0; ic < INVOC_COUNT; ic++) {
5200
            for (int i = 0; i < a.length; i += SPECIES.length()) {
5201
                IntVector av = IntVector.fromArray(SPECIES, a, i);
5202
                av.blend((long)b[i], vmask).intoArray(r, i);
5203
            }
5204
        }
5205
        assertBroadcastLongArraysEquals(r, a, b, mask, Int128VectorTests::blend);
5206
    }
5207

5208

5209
    @Test(dataProvider = "intUnaryOpShuffleProvider")
5210
    static void SelectFromInt128VectorTests(IntFunction<int[]> fa,
5211
                                           BiFunction<Integer,Integer,int[]> fs) {
5212
        int[] a = fa.apply(SPECIES.length());
5213
        int[] order = fs.apply(a.length, SPECIES.length());
5214
        int[] r = fr.apply(SPECIES.length());
5215

5216
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5217
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5218
            IntVector bv = IntVector.fromArray(SPECIES, order, i);
5219
            bv.selectFrom(av).intoArray(r, i);
5220
        }
5221

5222
        assertSelectFromArraysEquals(r, a, order, SPECIES.length());
5223
    }
5224

5225
    @Test(dataProvider = "intUnaryOpShuffleMaskProvider")
5226
    static void SelectFromInt128VectorTestsMaskedSmokeTest(IntFunction<int[]> fa,
5227
                                                           BiFunction<Integer,Integer,int[]> fs,
5228
                                                           IntFunction<boolean[]> fm) {
5229
        int[] a = fa.apply(SPECIES.length());
5230
        int[] order = fs.apply(a.length, SPECIES.length());
5231
        int[] r = fr.apply(SPECIES.length());
5232
        boolean[] mask = fm.apply(SPECIES.length());
5233
        VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5234

5235
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5236
            IntVector av = IntVector.fromArray(SPECIES, a, i);
5237
            IntVector bv = IntVector.fromArray(SPECIES, order, i);
5238
            bv.selectFrom(av, vmask).intoArray(r, i);
5239
        }
5240

5241
        assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
5242
    }
5243

5244
    @Test(dataProvider = "shuffleProvider")
5245
    static void shuffleMiscellaneousInt128VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5246
        int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5247

5248
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5249
            var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5250
            int hash = shuffle.hashCode();
5251
            int length = shuffle.length();
5252

5253
            int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5254
            int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5255
            Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5256
            Assert.assertEquals(length, SPECIES.length());
5257
        }
5258
    }
5259

5260
    @Test(dataProvider = "shuffleProvider")
5261
    static void shuffleToStringInt128VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5262
        int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5263

5264
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5265
            var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5266
            String str = shuffle.toString();
5267

5268
            int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5269
            Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
5270
                i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5271
        }
5272
    }
5273

5274
    @Test(dataProvider = "shuffleCompareOpProvider")
5275
    static void shuffleEqualsInt128VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
5276
        int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5277
        int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5278

5279
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5280
            var av = VectorShuffle.fromArray(SPECIES, a, i);
5281
            var bv = VectorShuffle.fromArray(SPECIES, b, i);
5282
            boolean eq = av.equals(bv);
5283
            int to = i + SPECIES.length();
5284
            Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
5285
        }
5286
    }
5287

5288
    @Test(dataProvider = "maskCompareOpProvider")
5289
    static void maskEqualsInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5290
        boolean[] a = fa.apply(SPECIES.length());
5291
        boolean[] b = fb.apply(SPECIES.length());
5292

5293
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5294
            var av = SPECIES.loadMask(a, i);
5295
            var bv = SPECIES.loadMask(b, i);
5296
            boolean equals = av.equals(bv);
5297
            int to = i + SPECIES.length();
5298
            Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
5299
        }
5300
    }
5301

5302
    static boolean beq(boolean a, boolean b) {
5303
        return (a == b);
5304
    }
5305

5306
    @Test(dataProvider = "maskCompareOpProvider")
5307
    static void maskEqInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5308
        boolean[] a = fa.apply(SPECIES.length());
5309
        boolean[] b = fb.apply(SPECIES.length());
5310
        boolean[] r = new boolean[a.length];
5311

5312
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5313
            var av = SPECIES.loadMask(a, i);
5314
            var bv = SPECIES.loadMask(b, i);
5315
            var cv = av.eq(bv);
5316
            cv.intoArray(r, i);
5317
        }
5318
        assertArraysEquals(r, a, b, Int128VectorTests::beq);
5319
    }
5320

5321
    @Test(dataProvider = "maskProvider")
5322
    static void maskHashCodeInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5323
        boolean[] a = fa.apply(SPECIES.length());
5324

5325
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5326
            var vmask = SPECIES.loadMask(a, i);
5327
            int hash = vmask.hashCode();
5328

5329
            boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5330
            int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5331
            Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5332
        }
5333
    }
5334

5335
    @Test(dataProvider = "maskProvider")
5336
    static void maskTrueCountInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5337
        boolean[] a = fa.apply(SPECIES.length());
5338

5339
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5340
            var vmask = SPECIES.loadMask(a, i);
5341
            int tcount = vmask.trueCount();
5342
            int expectedTcount = 0;
5343
            for (int j = i; j < i + SPECIES.length(); j++) {
5344
                expectedTcount += a[j] ? 1 : 0;
5345
            }
5346
            Assert.assertTrue(tcount == expectedTcount, "at index " + i + ", trueCount should be = " + expectedTcount + ", but is = " + tcount);
5347
        }
5348
    }
5349

5350
    @Test(dataProvider = "maskProvider")
5351
    static void maskLastTrueInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5352
        boolean[] a = fa.apply(SPECIES.length());
5353

5354
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5355
            var vmask = SPECIES.loadMask(a, i);
5356
            int ltrue = vmask.lastTrue();
5357
            int j = i + SPECIES.length() - 1;
5358
            for (; j >= i; j--) {
5359
                if (a[j]) break;
5360
            }
5361
            int expectedLtrue = j - i;
5362

5363
            Assert.assertTrue(ltrue == expectedLtrue, "at index " + i +
5364
                ", lastTrue should be = " + expectedLtrue + ", but is = " + ltrue);
5365
        }
5366
    }
5367

5368
    @Test(dataProvider = "maskProvider")
5369
    static void maskFirstTrueInt128VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5370
        boolean[] a = fa.apply(SPECIES.length());
5371

5372
        for (int i = 0; i < a.length; i += SPECIES.length()) {
5373
            var vmask = SPECIES.loadMask(a, i);
5374
            int ftrue = vmask.firstTrue();
5375
            int j = i;
5376
            for (; j < i + SPECIES.length() ; j++) {
5377
                if (a[j]) break;
5378
            }
5379
            int expectedFtrue = j - i;
5380

5381
            Assert.assertTrue(ftrue == expectedFtrue, "at index " + i +
5382
                ", firstTrue should be = " + expectedFtrue + ", but is = " + ftrue);
5383
        }
5384
    }
5385

5386
    @DataProvider
5387
    public static Object[][] longMaskProvider() {
5388
        return new Object[][]{
5389
                {0xFFFFFFFFFFFFFFFFL},
5390
                {0x0000000000000000L},
5391
                {0x5555555555555555L},
5392
                {0x0123456789abcdefL},
5393
        };
5394
    }
5395

5396
    @Test(dataProvider = "longMaskProvider")
5397
    static void maskFromToLongInt128VectorTestsSmokeTest(long inputLong) {
5398
        var vmask = VectorMask.fromLong(SPECIES, inputLong);
5399
        long outputLong = vmask.toLong();
5400
        Assert.assertEquals(outputLong, inputLong & (((1L << (SPECIES.length() - 1)) << 1) - 1));
5401
    }
5402

5403
    @DataProvider
5404
    public static Object[][] offsetProvider() {
5405
        return new Object[][]{
5406
                {0},
5407
                {-1},
5408
                {+1},
5409
                {+2},
5410
                {-2},
5411
        };
5412
    }
5413

5414
    @Test(dataProvider = "offsetProvider")
5415
    static void indexInRangeInt128VectorTestsSmokeTest(int offset) {
5416
        int limit = SPECIES.length() * BUFFER_REPS;
5417
        for (int i = 0; i < limit; i += SPECIES.length()) {
5418
            var actualMask = SPECIES.indexInRange(i + offset, limit);
5419
            var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5420
            assert(actualMask.equals(expectedMask));
5421
            for (int j = 0; j < SPECIES.length(); j++)  {
5422
                int index = i + j + offset;
5423
                Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5424
            }
5425
        }
5426
    }
5427

5428
    @DataProvider
5429
    public static Object[][] lengthProvider() {
5430
        return new Object[][]{
5431
                {0},
5432
                {1},
5433
                {32},
5434
                {37},
5435
                {1024},
5436
                {1024+1},
5437
                {1024+5},
5438
        };
5439
    }
5440

5441
    @Test(dataProvider = "lengthProvider")
5442
    static void loopBoundInt128VectorTestsSmokeTest(int length) {
5443
        int actualLoopBound = SPECIES.loopBound(length);
5444
        int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
5445
        Assert.assertEquals(actualLoopBound, expectedLoopBound);
5446
    }
5447

5448
    @Test
5449
    static void ElementSizeInt128VectorTestsSmokeTest() {
5450
        IntVector av = IntVector.zero(SPECIES);
5451
        int elsize = av.elementSize();
5452
        Assert.assertEquals(elsize, Integer.SIZE);
5453
    }
5454

5455
    @Test
5456
    static void VectorShapeInt128VectorTestsSmokeTest() {
5457
        IntVector av = IntVector.zero(SPECIES);
5458
        VectorShape vsh = av.shape();
5459
        assert(vsh.equals(VectorShape.S_128_BIT));
5460
    }
5461

5462
    @Test
5463
    static void ShapeWithLanesInt128VectorTestsSmokeTest() {
5464
        IntVector av = IntVector.zero(SPECIES);
5465
        VectorShape vsh = av.shape();
5466
        VectorSpecies species = vsh.withLanes(int.class);
5467
        assert(species.equals(SPECIES));
5468
    }
5469

5470
    @Test
5471
    static void ElementTypeInt128VectorTestsSmokeTest() {
5472
        IntVector av = IntVector.zero(SPECIES);
5473
        assert(av.species().elementType() == int.class);
5474
    }
5475

5476
    @Test
5477
    static void SpeciesElementSizeInt128VectorTestsSmokeTest() {
5478
        IntVector av = IntVector.zero(SPECIES);
5479
        assert(av.species().elementSize() == Integer.SIZE);
5480
    }
5481

5482
    @Test
5483
    static void VectorTypeInt128VectorTestsSmokeTest() {
5484
        IntVector av = IntVector.zero(SPECIES);
5485
        assert(av.species().vectorType() == av.getClass());
5486
    }
5487

5488
    @Test
5489
    static void WithLanesInt128VectorTestsSmokeTest() {
5490
        IntVector av = IntVector.zero(SPECIES);
5491
        VectorSpecies species = av.species().withLanes(int.class);
5492
        assert(species.equals(SPECIES));
5493
    }
5494

5495
    @Test
5496
    static void WithShapeInt128VectorTestsSmokeTest() {
5497
        IntVector av = IntVector.zero(SPECIES);
5498
        VectorShape vsh = av.shape();
5499
        VectorSpecies species = av.species().withShape(vsh);
5500
        assert(species.equals(SPECIES));
5501
    }
5502
}
5503

5504

5505
Product

Resources

Company
