1 /*
   2  * Copyright (c) 2018, 2025, 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  * @key randomness
  27  *
  28  * @library /test/lib
  29  * @modules jdk.incubator.vector
  30  * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Int64VectorTests
  31  */
  32 
  33 // -- This file was mechanically generated: Do not edit! -- //
  34 
  35 import jdk.incubator.vector.VectorShape;
  36 import jdk.incubator.vector.VectorSpecies;
  37 import jdk.incubator.vector.VectorShuffle;
  38 import jdk.incubator.vector.VectorMask;
  39 import jdk.incubator.vector.VectorOperators;
  40 import jdk.incubator.vector.Vector;
  41 import jdk.incubator.vector.VectorMath;
  42 
  43 import jdk.incubator.vector.IntVector;
  44 
  45 import org.testng.Assert;
  46 import org.testng.annotations.DataProvider;
  47 import org.testng.annotations.Test;
  48 
  49 import java.lang.Integer;
  50 import java.util.List;
  51 import java.util.Arrays;
  52 import java.util.function.BiFunction;
  53 import java.util.function.IntFunction;
  54 import java.util.Objects;
  55 import java.util.stream.Collectors;
  56 import java.util.stream.Stream;
  57 
  58 @Test
  59 public class Int64VectorTests extends AbstractVectorTest {
  60 
  61     static final VectorSpecies<Integer> SPECIES =
  62                 IntVector.SPECIES_64;
  63 
  64     static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
  65 
  66     static IntVector bcast_vec = IntVector.broadcast(SPECIES, (int)10);
  67 
  68 
  69     private static final int CONST_SHIFT = Integer.SIZE / 2;
  70 
  71     static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 64);
  72 
  73     static void assertArraysStrictlyEquals(int[] r, int[] a) {
  74         for (int i = 0; i < a.length; i++) {
  75             if (r[i] != a[i]) {
  76                 Assert.fail("at index #" + i + ", expected = " + a[i] + ", actual = " + r[i]);
  77             }
  78         }
  79     }
  80 
  81     interface FUnOp {
  82         int apply(int a);
  83     }
  84 
  85     static void assertArraysEquals(int[] r, int[] a, FUnOp f) {
  86         int i = 0;
  87         try {
  88             for (; i < a.length; i++) {
  89                 Assert.assertEquals(r[i], f.apply(a[i]));
  90             }
  91         } catch (AssertionError e) {
  92             Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
  93         }
  94     }
  95 
  96     interface FUnArrayOp {
  97         int[] apply(int a);
  98     }
  99 
 100     static void assertArraysEquals(int[] r, int[] a, FUnArrayOp f) {
 101         int i = 0;
 102         try {
 103             for (; i < a.length; i += SPECIES.length()) {
 104                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 105                   f.apply(a[i]));
 106             }
 107         } catch (AssertionError e) {
 108             int[] ref = f.apply(a[i]);
 109             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 110             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 111               + ", res: " + Arrays.toString(res)
 112               + "), at index #" + i);
 113         }
 114     }
 115 
 116     static void assertArraysEquals(int[] r, int[] a, boolean[] mask, FUnOp f) {
 117         int i = 0;
 118         try {
 119             for (; i < a.length; i++) {
 120                 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
 121             }
 122         } catch (AssertionError e) {
 123             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()]);
 124         }
 125     }
 126 
 127     interface FReductionOp {
 128         int apply(int[] a, int idx);
 129     }
 130 
 131     interface FReductionAllOp {
 132         int apply(int[] a);
 133     }
 134 
 135     static void assertReductionArraysEquals(int[] r, int rc, int[] a,
 136                                             FReductionOp f, FReductionAllOp fa) {
 137         int i = 0;
 138         try {
 139             Assert.assertEquals(rc, fa.apply(a));
 140             for (; i < a.length; i += SPECIES.length()) {
 141                 Assert.assertEquals(r[i], f.apply(a, i));
 142             }
 143         } catch (AssertionError e) {
 144             Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
 145             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 146         }
 147     }
 148 
 149     interface FReductionMaskedOp {
 150         int apply(int[] a, int idx, boolean[] mask);
 151     }
 152 
 153     interface FReductionAllMaskedOp {
 154         int apply(int[] a, boolean[] mask);
 155     }
 156 
 157     static void assertReductionArraysEqualsMasked(int[] r, int rc, int[] a, boolean[] mask,
 158                                             FReductionMaskedOp f, FReductionAllMaskedOp fa) {
 159         int i = 0;
 160         try {
 161             Assert.assertEquals(rc, fa.apply(a, mask));
 162             for (; i < a.length; i += SPECIES.length()) {
 163                 Assert.assertEquals(r[i], f.apply(a, i, mask));
 164             }
 165         } catch (AssertionError e) {
 166             Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
 167             Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
 168         }
 169     }
 170 
 171     interface FReductionOpLong {
 172         long apply(int[] a, int idx);
 173     }
 174 
 175     interface FReductionAllOpLong {
 176         long apply(int[] a);
 177     }
 178 
 179     static void assertReductionLongArraysEquals(long[] r, long rc, int[] a,
 180                                             FReductionOpLong f, FReductionAllOpLong fa) {
 181         int i = 0;
 182         try {
 183             Assert.assertEquals(rc, fa.apply(a));
 184             for (; i < a.length; i += SPECIES.length()) {
 185                 Assert.assertEquals(r[i], f.apply(a, i));
 186             }
 187         } catch (AssertionError e) {
 188             Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
 189             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 190         }
 191     }
 192 
 193     interface FReductionMaskedOpLong {
 194         long apply(int[] a, int idx, boolean[] mask);
 195     }
 196 
 197     interface FReductionAllMaskedOpLong {
 198         long apply(int[] a, boolean[] mask);
 199     }
 200 
 201     static void assertReductionLongArraysEqualsMasked(long[] r, long rc, int[] a, boolean[] mask,
 202                                             FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
 203         int i = 0;
 204         try {
 205             Assert.assertEquals(rc, fa.apply(a, mask));
 206             for (; i < a.length; i += SPECIES.length()) {
 207                 Assert.assertEquals(r[i], f.apply(a, i, mask));
 208             }
 209         } catch (AssertionError e) {
 210             Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
 211             Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
 212         }
 213     }
 214 
 215     interface FBoolReductionOp {
 216         boolean apply(boolean[] a, int idx);
 217     }
 218 
 219     static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
 220         int i = 0;
 221         try {
 222             for (; i < a.length; i += SPECIES.length()) {
 223                 Assert.assertEquals(r[i], f.apply(a, i));
 224             }
 225         } catch (AssertionError e) {
 226             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 227         }
 228     }
 229 
 230     interface FMaskReductionOp {
 231         int apply(boolean[] a, int idx);
 232     }
 233 
 234     static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) {
 235         int i = 0;
 236         try {
 237             for (; i < a.length; i += SPECIES.length()) {
 238                 Assert.assertEquals(r[i], f.apply(a, i));
 239             }
 240         } catch (AssertionError e) {
 241             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 242         }
 243     }
 244 
 245     static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, int vector_len) {
 246         int i = 0, j = 0;
 247         try {
 248             for (; i < a.length; i += vector_len) {
 249                 for (j = 0; j < vector_len; j++) {
 250                     Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 251                 }
 252             }
 253         } catch (AssertionError e) {
 254             int idx = i + j;
 255             Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
 256         }
 257     }
 258 
 259     static void assertcompressArraysEquals(int[] r, int[] a, boolean[] m, int vector_len) {
 260         int i = 0, j = 0, k = 0;
 261         try {
 262             for (; i < a.length; i += vector_len) {
 263                 k = 0;
 264                 for (j = 0; j < vector_len; j++) {
 265                     if (m[(i + j) % SPECIES.length()]) {
 266                         Assert.assertEquals(r[i + k], a[i + j]);
 267                         k++;
 268                     }
 269                 }
 270                 for (; k < vector_len; k++) {
 271                     Assert.assertEquals(r[i + k], (int)0);
 272                 }
 273             }
 274         } catch (AssertionError e) {
 275             int idx = i + k;
 276             if (m[(i + j) % SPECIES.length()]) {
 277                 Assert.assertEquals(r[idx], a[i + j], "at index #" + idx);
 278             } else {
 279                 Assert.assertEquals(r[idx], (int)0, "at index #" + idx);
 280             }
 281         }
 282     }
 283 
 284     static void assertexpandArraysEquals(int[] r, int[] a, boolean[] m, int vector_len) {
 285         int i = 0, j = 0, k = 0;
 286         try {
 287             for (; i < a.length; i += vector_len) {
 288                 k = 0;
 289                 for (j = 0; j < vector_len; j++) {
 290                     if (m[(i + j) % SPECIES.length()]) {
 291                         Assert.assertEquals(r[i + j], a[i + k]);
 292                         k++;
 293                     } else {
 294                         Assert.assertEquals(r[i + j], (int)0);
 295                     }
 296                 }
 297             }
 298         } catch (AssertionError e) {
 299             int idx = i + j;
 300             if (m[idx % SPECIES.length()]) {
 301                 Assert.assertEquals(r[idx], a[i + k], "at index #" + idx);
 302             } else {
 303                 Assert.assertEquals(r[idx], (int)0, "at index #" + idx);
 304             }
 305         }
 306     }
 307 
 308     static void assertSelectFromTwoVectorEquals(int[] r, int[] order, int[] a, int[] b, int vector_len) {
 309         int i = 0, j = 0;
 310         boolean is_exceptional_idx = false;
 311         int idx = 0, wrapped_index = 0, oidx = 0;
 312         try {
 313             for (; i < a.length; i += vector_len) {
 314                 for (j = 0; j < vector_len; j++) {
 315                     idx = i + j;
 316                     wrapped_index = Math.floorMod((int)order[idx], 2 * vector_len);
 317                     is_exceptional_idx = wrapped_index >= vector_len;
 318                     oidx = is_exceptional_idx ? (wrapped_index - vector_len) : wrapped_index;
 319                     Assert.assertEquals(r[idx], (is_exceptional_idx ? b[i + oidx] : a[i + oidx]));
 320                 }
 321             }
 322         } catch (AssertionError e) {
 323             Assert.assertEquals(r[idx], (is_exceptional_idx ? b[i + oidx] : a[i + oidx]), "at index #" + idx + ", order = " + order[idx] + ", a = " + a[i + oidx] + ", b = " + b[i + oidx]);
 324         }
 325     }
 326 
 327     static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, int vector_len) {
 328         int i = 0, j = 0;
 329         try {
 330             for (; i < a.length; i += vector_len) {
 331                 for (j = 0; j < vector_len; j++) {
 332                     Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 333                 }
 334             }
 335         } catch (AssertionError e) {
 336             int idx = i + j;
 337             Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
 338         }
 339     }
 340 
 341     static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) {
 342         int i = 0, j = 0;
 343         try {
 344             for (; i < a.length; i += vector_len) {
 345                 for (j = 0; j < vector_len; j++) {
 346                     if (mask[j % SPECIES.length()])
 347                          Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 348                     else
 349                          Assert.assertEquals(r[i+j], (int)0);
 350                 }
 351             }
 352         } catch (AssertionError e) {
 353             int idx = i + j;
 354             if (mask[j % SPECIES.length()])
 355                 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 356             else
 357                 Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 358         }
 359     }
 360 
 361     static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) {
 362         int i = 0, j = 0;
 363         try {
 364             for (; i < a.length; i += vector_len) {
 365                 for (j = 0; j < vector_len; j++) {
 366                     if (mask[j % SPECIES.length()])
 367                          Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 368                     else
 369                          Assert.assertEquals(r[i+j], (int)0);
 370                 }
 371             }
 372         } catch (AssertionError e) {
 373             int idx = i + j;
 374             if (mask[j % SPECIES.length()])
 375                 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()]);
 376             else
 377                 Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 378         }
 379     }
 380 
 381     static void assertBroadcastArraysEquals(int[] r, int[] a) {
 382         int i = 0;
 383         for (; i < a.length; i += SPECIES.length()) {
 384             int idx = i;
 385             for (int j = idx; j < (idx + SPECIES.length()); j++)
 386                 a[j]=a[idx];
 387         }
 388 
 389         try {
 390             for (i = 0; i < a.length; i++) {
 391                 Assert.assertEquals(r[i], a[i]);
 392             }
 393         } catch (AssertionError e) {
 394             Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
 395         }
 396     }
 397 
 398     interface FBinOp {
 399         int apply(int a, int b);
 400     }
 401 
 402     interface FBinMaskOp {
 403         int apply(int a, int b, boolean m);
 404 
 405         static FBinMaskOp lift(FBinOp f) {
 406             return (a, b, m) -> m ? f.apply(a, b) : a;
 407         }
 408     }
 409 
 410     static void assertArraysEqualsAssociative(int[] rl, int[] rr, int[] a, int[] b, int[] c, FBinOp f) {
 411         int i = 0;
 412         try {
 413             for (; i < a.length; i++) {
 414                 //Left associative
 415                 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i]), c[i]));
 416 
 417                 //Right associative
 418                 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i])));
 419 
 420                 //Results equal sanity check
 421                 Assert.assertEquals(rl[i], rr[i]);
 422             }
 423         } catch (AssertionError e) {
 424             Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i]), c[i]), "left associative test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 425             Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i])), "right associative test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 426             Assert.assertEquals(rl[i], rr[i], "Result checks not equal at index #" + i + "leftRes = " + rl[i] + ", rightRes = " + rr[i]);
 427         }
 428     }
 429 
 430    static void assertArraysEqualsAssociative(int[] rl, int[] rr, int[] a, int[] b, int[] c, boolean[] mask, FBinOp f) {
 431        assertArraysEqualsAssociative(rl, rr, a, b, c, mask, FBinMaskOp.lift(f));
 432    }
 433 
 434     static void assertArraysEqualsAssociative(int[] rl, int[] rr, int[] a, int[] b, int[] c, boolean[] mask, FBinMaskOp f) {
 435         int i = 0;
 436         boolean mask_bit = false;
 437         try {
 438             for (; i < a.length; i++) {
 439                 mask_bit = mask[i % SPECIES.length()];
 440                 //Left associative
 441                 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i], mask_bit), c[i], mask_bit));
 442 
 443                 //Right associative
 444                 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i], mask_bit), mask_bit));
 445 
 446                 //Results equal sanity check
 447                 Assert.assertEquals(rl[i], rr[i]);
 448             }
 449         } catch (AssertionError e) {
 450             Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i], mask_bit), c[i], mask_bit), "left associative masked test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i] + ", mask = " + mask_bit);
 451             Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i], mask_bit), mask_bit), "right associative masked test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i] + ", mask = " + mask_bit);
 452             Assert.assertEquals(rl[i], rr[i], "Result checks not equal at index #" + i + "leftRes = " + rl[i] + ", rightRes = " + rr[i]);
 453         }
 454     }
 455 
 456     static void assertArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
 457         int i = 0;
 458         try {
 459             for (; i < a.length; i++) {
 460                 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
 461             }
 462         } catch (AssertionError e) {
 463             Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
 464         }
 465     }
 466 
 467     static void assertArraysEquals(int[] r, int[] a, int b, FBinOp f) {
 468         int i = 0;
 469         try {
 470             for (; i < a.length; i++) {
 471                 Assert.assertEquals(r[i], f.apply(a[i], b));
 472             }
 473         } catch (AssertionError e) {
 474             Assert.assertEquals(r[i], f.apply(a[i], b), "(" + a[i] + ", " + b + ") at index #" + i);
 475         }
 476     }
 477 
 478     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
 479         int i = 0;
 480         try {
 481             for (; i < a.length; i++) {
 482                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
 483             }
 484         } catch (AssertionError e) {
 485             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
 486                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 487         }
 488     }
 489 
 490     static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
 491         int i = 0;
 492         try {
 493             for (; i < a.length; i++) {
 494                 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
 495             }
 496         } catch (AssertionError e) {
 497             Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
 498                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 499         }
 500     }
 501 
 502     static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
 503         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 504     }
 505 
 506     static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
 507         int i = 0;
 508         try {
 509             for (; i < a.length; i++) {
 510                 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
 511             }
 512         } catch (AssertionError err) {
 513             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()]);
 514         }
 515     }
 516 
 517     static void assertArraysEquals(int[] r, int[] a, int b, boolean[] mask, FBinOp f) {
 518         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 519     }
 520 
 521     static void assertArraysEquals(int[] r, int[] a, int b, boolean[] mask, FBinMaskOp f) {
 522         int i = 0;
 523         try {
 524             for (; i < a.length; i++) {
 525                 Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]));
 526             }
 527         } catch (AssertionError err) {
 528             Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b + ", mask = " + mask[i % SPECIES.length()]);
 529         }
 530     }
 531 
 532     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
 533         assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 534     }
 535 
 536     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
 537         int i = 0;
 538         try {
 539             for (; i < a.length; i++) {
 540                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 541             }
 542         } catch (AssertionError err) {
 543             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 544                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 545                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 546                                 mask[i % SPECIES.length()]);
 547         }
 548     }
 549 
 550     static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
 551         assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 552     }
 553 
 554     static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
 555         int i = 0;
 556         try {
 557             for (; i < a.length; i++) {
 558                 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
 559             }
 560         } catch (AssertionError err) {
 561             Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
 562                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 563                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 564                                 mask[i % SPECIES.length()]);
 565         }
 566     }
 567 
 568     static void assertShiftArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
 569         int i = 0;
 570         int j = 0;
 571         try {
 572             for (; j < a.length; j += SPECIES.length()) {
 573                 for (i = 0; i < SPECIES.length(); i++) {
 574                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
 575                 }
 576             }
 577         } catch (AssertionError e) {
 578             Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
 579         }
 580     }
 581 
 582     static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
 583         assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 584     }
 585 
 586     static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
 587         int i = 0;
 588         int j = 0;
 589         try {
 590             for (; j < a.length; j += SPECIES.length()) {
 591                 for (i = 0; i < SPECIES.length(); i++) {
 592                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
 593                 }
 594             }
 595         } catch (AssertionError err) {
 596             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]);
 597         }
 598     }
 599 
 600     interface FBinConstOp {
 601         int apply(int a);
 602     }
 603 
 604     interface FBinConstMaskOp {
 605         int apply(int a, boolean m);
 606 
 607         static FBinConstMaskOp lift(FBinConstOp f) {
 608             return (a, m) -> m ? f.apply(a) : a;
 609         }
 610     }
 611 
 612     static void assertShiftConstEquals(int[] r, int[] a, FBinConstOp f) {
 613         int i = 0;
 614         int j = 0;
 615         try {
 616             for (; j < a.length; j += SPECIES.length()) {
 617                 for (i = 0; i < SPECIES.length(); i++) {
 618                     Assert.assertEquals(r[i+j], f.apply(a[i+j]));
 619                 }
 620             }
 621         } catch (AssertionError e) {
 622             Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
 623         }
 624     }
 625 
 626     static void assertShiftConstEquals(int[] r, int[] a, boolean[] mask, FBinConstOp f) {
 627         assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
 628     }
 629 
 630     static void assertShiftConstEquals(int[] r, int[] a, boolean[] mask, FBinConstMaskOp f) {
 631         int i = 0;
 632         int j = 0;
 633         try {
 634             for (; j < a.length; j += SPECIES.length()) {
 635                 for (i = 0; i < SPECIES.length(); i++) {
 636                     Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
 637                 }
 638             }
 639         } catch (AssertionError err) {
 640             Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
 641         }
 642     }
 643 
 644     interface FTernOp {
 645         int apply(int a, int b, int c);
 646     }
 647 
 648     interface FTernMaskOp {
 649         int apply(int a, int b, int c, boolean m);
 650 
 651         static FTernMaskOp lift(FTernOp f) {
 652             return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
 653         }
 654     }
 655 
 656     static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
 657         int i = 0;
 658         try {
 659             for (; i < a.length; i++) {
 660                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
 661             }
 662         } catch (AssertionError e) {
 663             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 664         }
 665     }
 666 
 667     static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernOp f) {
 668         assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 669     }
 670 
 671     static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernMaskOp f) {
 672         int i = 0;
 673         try {
 674             for (; i < a.length; i++) {
 675                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
 676             }
 677         } catch (AssertionError err) {
 678             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
 679               + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 680         }
 681     }
 682 
 683     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
 684         int i = 0;
 685         try {
 686             for (; i < a.length; i++) {
 687                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
 688             }
 689         } catch (AssertionError e) {
 690             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
 691                                 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
 692                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 693         }
 694     }
 695 
 696     static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
 697         int i = 0;
 698         try {
 699             for (; i < a.length; i++) {
 700                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
 701             }
 702         } catch (AssertionError e) {
 703             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
 704                                 i + ", input1 = " + a[i] + ", input2 = " +
 705                                 b[(i / SPECIES.length()) * SPECIES.length()] + ",  input3 = " + c[i]);
 706         }
 707     }
 708 
 709     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 710                                             FTernOp f) {
 711         assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 712     }
 713 
 714     static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 715                                             FTernMaskOp f) {
 716         int i = 0;
 717         try {
 718             for (; i < a.length; i++) {
 719                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 720                                     mask[i % SPECIES.length()]));
 721             }
 722         } catch (AssertionError err) {
 723             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 724                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
 725                                 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 726                                 mask[i % SPECIES.length()]);
 727         }
 728     }
 729 
 730     static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 731                                             FTernOp f) {
 732         assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 733     }
 734 
 735     static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 736                                             FTernMaskOp f) {
 737         int i = 0;
 738         try {
 739             for (; i < a.length; i++) {
 740                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 741                                     mask[i % SPECIES.length()]));
 742             }
 743         } catch (AssertionError err) {
 744             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 745                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 746                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 747                                 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 748         }
 749     }
 750 
 751     static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
 752         int i = 0;
 753         try {
 754             for (; i < a.length; i++) {
 755                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 756                                     c[(i / SPECIES.length()) * SPECIES.length()]));
 757             }
 758         } catch (AssertionError e) {
 759             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 760                                 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
 761                                 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
 762                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 763         }
 764     }
 765 
 766     static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 767                                                   FTernOp f) {
 768         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 769     }
 770 
 771     static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
 772                                                   FTernMaskOp f) {
 773         int i = 0;
 774         try {
 775             for (; i < a.length; i++) {
 776                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 777                                     c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 778             }
 779         } catch (AssertionError err) {
 780             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 781                                 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
 782                                 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 783                                 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 784                                 mask[i % SPECIES.length()]);
 785         }
 786     }
 787 
 788 
 789 
 790     interface FGatherScatterOp {
 791         int[] apply(int[] a, int ix, int[] b, int iy);
 792     }
 793 
 794     static void assertArraysEquals(int[] r, int[] a, int[] b, FGatherScatterOp f) {
 795         int i = 0;
 796         try {
 797             for (; i < a.length; i += SPECIES.length()) {
 798                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 799                   f.apply(a, i, b, i));
 800             }
 801         } catch (AssertionError e) {
 802             int[] ref = f.apply(a, i, b, i);
 803             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 804             Assert.assertEquals(res, ref,
 805               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 806               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 807               + ", b: "
 808               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 809               + " at index #" + i);
 810         }
 811     }
 812 
 813     interface FGatherMaskedOp {
 814         int[] apply(int[] a, int ix, boolean[] mask, int[] b, int iy);
 815     }
 816 
 817     interface FScatterMaskedOp {
 818         int[] apply(int[] r, int[] a, int ix, boolean[] mask, int[] b, int iy);
 819     }
 820 
 821     static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
 822         int i = 0;
 823         try {
 824             for (; i < a.length; i += SPECIES.length()) {
 825                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 826                   f.apply(a, i, mask, b, i));
 827             }
 828         } catch (AssertionError e) {
 829             int[] ref = f.apply(a, i, mask, b, i);
 830             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 831             Assert.assertEquals(res, ref,
 832               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 833               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 834               + ", b: "
 835               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 836               + ", mask: "
 837               + Arrays.toString(mask)
 838               + " at index #" + i);
 839         }
 840     }
 841 
 842     static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
 843         int i = 0;
 844         try {
 845             for (; i < a.length; i += SPECIES.length()) {
 846                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 847                   f.apply(r, a, i, mask, b, i));
 848             }
 849         } catch (AssertionError e) {
 850             int[] ref = f.apply(r, a, i, mask, b, i);
 851             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 852             Assert.assertEquals(res, ref,
 853               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 854               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 855               + ", b: "
 856               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 857               + ", r: "
 858               + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
 859               + ", mask: "
 860               + Arrays.toString(mask)
 861               + " at index #" + i);
 862         }
 863     }
 864 
 865     interface FLaneOp {
 866         int[] apply(int[] a, int origin, int idx);
 867     }
 868 
 869     static void assertArraysEquals(int[] r, int[] a, int origin, FLaneOp f) {
 870         int i = 0;
 871         try {
 872             for (; i < a.length; i += SPECIES.length()) {
 873                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 874                   f.apply(a, origin, i));
 875             }
 876         } catch (AssertionError e) {
 877             int[] ref = f.apply(a, origin, i);
 878             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 879             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 880               + ", res: " + Arrays.toString(res)
 881               + "), at index #" + i);
 882         }
 883     }
 884 
 885     interface FLaneBop {
 886         int[] apply(int[] a, int[] b, int origin, int idx);
 887     }
 888 
 889     static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, FLaneBop f) {
 890         int i = 0;
 891         try {
 892             for (; i < a.length; i += SPECIES.length()) {
 893                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 894                   f.apply(a, b, origin, i));
 895             }
 896         } catch (AssertionError e) {
 897             int[] ref = f.apply(a, b, origin, i);
 898             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 899             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 900               + ", res: " + Arrays.toString(res)
 901               + "), at index #" + i
 902               + ", at origin #" + origin);
 903         }
 904     }
 905 
 906     interface FLaneMaskedBop {
 907         int[] apply(int[] a, int[] b, int origin, boolean[] mask, int idx);
 908     }
 909 
 910     static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
 911         int i = 0;
 912         try {
 913             for (; i < a.length; i += SPECIES.length()) {
 914                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 915                   f.apply(a, b, origin, mask, i));
 916             }
 917         } catch (AssertionError e) {
 918             int[] ref = f.apply(a, b, origin, mask, i);
 919             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 920             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 921               + ", res: " + Arrays.toString(res)
 922               + "), at index #" + i
 923               + ", at origin #" + origin);
 924         }
 925     }
 926 
 927     interface FLanePartBop {
 928         int[] apply(int[] a, int[] b, int origin, int part, int idx);
 929     }
 930 
 931     static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, FLanePartBop f) {
 932         int i = 0;
 933         try {
 934             for (; i < a.length; i += SPECIES.length()) {
 935                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 936                   f.apply(a, b, origin, part, i));
 937             }
 938         } catch (AssertionError e) {
 939             int[] ref = f.apply(a, b, origin, part, i);
 940             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 941             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 942               + ", res: " + Arrays.toString(res)
 943               + "), at index #" + i
 944               + ", at origin #" + origin
 945               + ", with part #" + part);
 946         }
 947     }
 948 
 949     interface FLanePartMaskedBop {
 950         int[] apply(int[] a, int[] b, int origin, int part, boolean[] mask, int idx);
 951     }
 952 
 953     static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
 954         int i = 0;
 955         try {
 956             for (; i < a.length; i += SPECIES.length()) {
 957                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 958                   f.apply(a, b, origin, part, mask, i));
 959             }
 960         } catch (AssertionError e) {
 961             int[] ref = f.apply(a, b, origin, part, mask, i);
 962             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 963             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 964               + ", res: " + Arrays.toString(res)
 965               + "), at index #" + i
 966               + ", at origin #" + origin
 967               + ", with part #" + part);
 968         }
 969     }
 970 
 971 
 972     static void assertArraysEquals(int[] r, int[] a, int offs) {
 973         int i = 0;
 974         try {
 975             for (; i < r.length; i++) {
 976                 Assert.assertEquals(r[i], (int)(a[i+offs]));
 977             }
 978         } catch (AssertionError e) {
 979             Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 980         }
 981     }
 982 
 983 
 984 
 985     static void assertArraysEquals(long[] r, int[] a, int offs) {
 986         int i = 0;
 987         try {
 988             for (; i < r.length; i++) {
 989                 Assert.assertEquals(r[i], (long)(a[i+offs]));
 990             }
 991         } catch (AssertionError e) {
 992             Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 993         }
 994     }
 995 
 996     static void assertArraysEquals(double[] r, int[] a, int offs) {
 997         int i = 0;
 998         try {
 999             for (; i < r.length; i++) {
1000                 Assert.assertEquals(r[i], (double)(a[i+offs]));
1001             }
1002         } catch (AssertionError e) {
1003             Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1004         }
1005     }
1006 
1007     static int bits(int e) {
1008         return  e;
1009     }
1010 
1011     static final List<IntFunction<int[]>> INT_GENERATORS = List.of(
1012             withToString("int[-i * 5]", (int s) -> {
1013                 return fill(s * BUFFER_REPS,
1014                             i -> (int)(-i * 5));
1015             }),
1016             withToString("int[i * 5]", (int s) -> {
1017                 return fill(s * BUFFER_REPS,
1018                             i -> (int)(i * 5));
1019             }),
1020             withToString("int[i + 1]", (int s) -> {
1021                 return fill(s * BUFFER_REPS,
1022                             i -> (((int)(i + 1) == 0) ? 1 : (int)(i + 1)));
1023             }),
1024             withToString("int[cornerCaseValue(i)]", (int s) -> {
1025                 return fill(s * BUFFER_REPS,
1026                             i -> cornerCaseValue(i));
1027             })
1028     );
1029 
1030     static final List<IntFunction<int[]>> INT_SATURATING_GENERATORS = List.of(
1031             withToString("int[Integer.MIN_VALUE]", (int s) -> {
1032                 return fill(s * BUFFER_REPS,
1033                             i -> (int)(Integer.MIN_VALUE));
1034             }),
1035             withToString("int[Integer.MAX_VALUE]", (int s) -> {
1036                 return fill(s * BUFFER_REPS,
1037                             i -> (int)(Integer.MAX_VALUE));
1038             }),
1039             withToString("int[Integer.MAX_VALUE - 100]", (int s) -> {
1040                 return fill(s * BUFFER_REPS,
1041                             i -> (int)(Integer.MAX_VALUE - 100));
1042             }),
1043             withToString("int[Integer.MIN_VALUE + 100]", (int s) -> {
1044                 return fill(s * BUFFER_REPS,
1045                             i -> (int)(Integer.MIN_VALUE + 100));
1046             }),
1047             withToString("int[-i * 5]", (int s) -> {
1048                 return fill(s * BUFFER_REPS,
1049                             i -> (int)(-i * 5));
1050             }),
1051             withToString("int[i * 5]", (int s) -> {
1052                 return fill(s * BUFFER_REPS,
1053                             i -> (int)(i * 5));
1054             })
1055     );
1056 
1057     static final List<IntFunction<int[]>> INT_SATURATING_GENERATORS_ASSOC = List.of(
1058             withToString("int[Integer.MAX_VALUE]", (int s) -> {
1059                 return fill(s * BUFFER_REPS,
1060                             i -> (int)(Integer.MAX_VALUE));
1061             }),
1062             withToString("int[Integer.MAX_VALUE - 100]", (int s) -> {
1063                 return fill(s * BUFFER_REPS,
1064                             i -> (int)(Integer.MAX_VALUE - 100));
1065             }),
1066             withToString("int[-1]", (int s) -> {
1067                 return fill(s * BUFFER_REPS,
1068                             i -> (int)(-1));
1069             })
1070     );
1071 
1072     // Create combinations of pairs
1073     // @@@ Might be sensitive to order e.g. div by 0
1074     static final List<List<IntFunction<int[]>>> INT_GENERATOR_PAIRS =
1075         Stream.of(INT_GENERATORS.get(0)).
1076                 flatMap(fa -> INT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1077                 collect(Collectors.toList());
1078 
1079     static final List<List<IntFunction<int[]>>> INT_SATURATING_GENERATOR_PAIRS =
1080         Stream.of(INT_GENERATORS.get(0)).
1081                 flatMap(fa -> INT_SATURATING_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1082                 collect(Collectors.toList());
1083 
1084     static final List<List<IntFunction<int[]>>> INT_SATURATING_GENERATOR_TRIPLETS =
1085             Stream.of(INT_GENERATORS.get(1))
1086                     .flatMap(fa -> INT_SATURATING_GENERATORS_ASSOC.stream().map(fb -> List.of(fa, fb)))
1087                     .flatMap(pair -> INT_SATURATING_GENERATORS_ASSOC.stream().map(f -> List.of(pair.get(0), pair.get(1), f)))
1088                     .collect(Collectors.toList());
1089 
1090     @DataProvider
1091     public Object[][] boolUnaryOpProvider() {
1092         return BOOL_ARRAY_GENERATORS.stream().
1093                 map(f -> new Object[]{f}).
1094                 toArray(Object[][]::new);
1095     }
1096 
1097     static final List<List<IntFunction<int[]>>> INT_GENERATOR_TRIPLES =
1098         INT_GENERATOR_PAIRS.stream().
1099                 flatMap(pair -> INT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1100                 collect(Collectors.toList());
1101 
1102     static final List<IntFunction<int[]>> SELECT_FROM_INDEX_GENERATORS = List.of(
1103             withToString("int[0..VECLEN*2)", (int s) -> {
1104                 return fill(s * BUFFER_REPS,
1105                             i -> (int)(RAND.nextInt()));
1106             })
1107     );
1108 
1109     static final List<List<IntFunction<int[]>>> INT_GENERATOR_SELECT_FROM_TRIPLES =
1110         INT_GENERATOR_PAIRS.stream().
1111                 flatMap(pair -> SELECT_FROM_INDEX_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1112                 collect(Collectors.toList());
1113 
1114     @DataProvider
1115     public Object[][] intBinaryOpProvider() {
1116         return INT_GENERATOR_PAIRS.stream().map(List::toArray).
1117                 toArray(Object[][]::new);
1118     }
1119 
1120     @DataProvider
1121     public Object[][] intSaturatingBinaryOpProvider() {
1122         return INT_SATURATING_GENERATOR_PAIRS.stream().map(List::toArray).
1123                 toArray(Object[][]::new);
1124     }
1125 
1126     @DataProvider
1127     public Object[][] intSaturatingBinaryOpAssocProvider() {
1128         return INT_SATURATING_GENERATOR_TRIPLETS.stream().map(List::toArray).
1129                 toArray(Object[][]::new);
1130     }
1131 
1132     @DataProvider
1133     public Object[][] intSaturatingBinaryOpAssocMaskProvider() {
1134         return BOOLEAN_MASK_GENERATORS.stream().
1135                 flatMap(fm -> INT_SATURATING_GENERATOR_TRIPLETS.stream().map(lfa -> {
1136                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1137                 })).
1138                 toArray(Object[][]::new);
1139     }
1140 
1141 
1142     @DataProvider
1143     public Object[][] intIndexedOpProvider() {
1144         return INT_GENERATOR_PAIRS.stream().map(List::toArray).
1145                 toArray(Object[][]::new);
1146     }
1147 
1148     @DataProvider
1149     public Object[][] intSaturatingBinaryOpMaskProvider() {
1150         return BOOLEAN_MASK_GENERATORS.stream().
1151                 flatMap(fm -> INT_SATURATING_GENERATOR_PAIRS.stream().map(lfa -> {
1152                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1153                 })).
1154                 toArray(Object[][]::new);
1155     }
1156 
1157    @DataProvider
1158    public Object[][] intSaturatingUnaryOpProvider() {
1159        return INT_SATURATING_GENERATORS.stream().
1160                     map(f -> new Object[]{f}).
1161                     toArray(Object[][]::new);
1162    }
1163 
1164    @DataProvider
1165    public Object[][] intSaturatingUnaryOpMaskProvider() {
1166         return BOOLEAN_MASK_GENERATORS.stream().
1167                 flatMap(fm -> INT_SATURATING_GENERATORS.stream().map(fa -> {
1168                     return new Object[] {fa, fm};
1169                 })).
1170                 toArray(Object[][]::new);
1171    }
1172 
1173     @DataProvider
1174     public Object[][] intBinaryOpMaskProvider() {
1175         return BOOLEAN_MASK_GENERATORS.stream().
1176                 flatMap(fm -> INT_GENERATOR_PAIRS.stream().map(lfa -> {
1177                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1178                 })).
1179                 toArray(Object[][]::new);
1180     }
1181 
1182     @DataProvider
1183     public Object[][] intTernaryOpProvider() {
1184         return INT_GENERATOR_TRIPLES.stream().map(List::toArray).
1185                 toArray(Object[][]::new);
1186     }
1187 
1188     @DataProvider
1189     public Object[][] intSelectFromTwoVectorOpProvider() {
1190         return INT_GENERATOR_SELECT_FROM_TRIPLES.stream().map(List::toArray).
1191                 toArray(Object[][]::new);
1192     }
1193 
1194     @DataProvider
1195     public Object[][] intTernaryOpMaskProvider() {
1196         return BOOLEAN_MASK_GENERATORS.stream().
1197                 flatMap(fm -> INT_GENERATOR_TRIPLES.stream().map(lfa -> {
1198                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1199                 })).
1200                 toArray(Object[][]::new);
1201     }
1202 
1203     @DataProvider
1204     public Object[][] intUnaryOpProvider() {
1205         return INT_GENERATORS.stream().
1206                 map(f -> new Object[]{f}).
1207                 toArray(Object[][]::new);
1208     }
1209 
1210     @DataProvider
1211     public Object[][] intUnaryOpMaskProvider() {
1212         return BOOLEAN_MASK_GENERATORS.stream().
1213                 flatMap(fm -> INT_GENERATORS.stream().map(fa -> {
1214                     return new Object[] {fa, fm};
1215                 })).
1216                 toArray(Object[][]::new);
1217     }
1218 
1219     @DataProvider
1220     public Object[][] maskProvider() {
1221         return BOOLEAN_MASK_GENERATORS.stream().
1222                 map(f -> new Object[]{f}).
1223                 toArray(Object[][]::new);
1224     }
1225 
1226     @DataProvider
1227     public Object[][] maskCompareOpProvider() {
1228         return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1229                 toArray(Object[][]::new);
1230     }
1231 
1232     @DataProvider
1233     public Object[][] shuffleProvider() {
1234         return INT_SHUFFLE_GENERATORS.stream().
1235                 map(f -> new Object[]{f}).
1236                 toArray(Object[][]::new);
1237     }
1238 
1239     @DataProvider
1240     public Object[][] shuffleCompareOpProvider() {
1241         return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1242                 toArray(Object[][]::new);
1243     }
1244 
1245     @DataProvider
1246     public Object[][] intUnaryOpShuffleProvider() {
1247         return INT_SHUFFLE_GENERATORS.stream().
1248                 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
1249                     return new Object[] {fa, fs};
1250                 })).
1251                 toArray(Object[][]::new);
1252     }
1253 
1254     @DataProvider
1255     public Object[][] intUnaryOpShuffleMaskProvider() {
1256         return BOOLEAN_MASK_GENERATORS.stream().
1257                 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1258                     flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
1259                         return new Object[] {fa, fs, fm};
1260                 }))).
1261                 toArray(Object[][]::new);
1262     }
1263 
1264     static final List<IntFunction<int[]>> INT_COMPARE_GENERATORS = List.of(
1265             withToString("int[i]", (int s) -> {
1266                 return fill(s * BUFFER_REPS,
1267                             i -> (int)i);
1268             }),
1269             withToString("int[i - length / 2]", (int s) -> {
1270                 return fill(s * BUFFER_REPS,
1271                             i -> (int)(i - (s * BUFFER_REPS / 2)));
1272             }),
1273             withToString("int[i + 1]", (int s) -> {
1274                 return fill(s * BUFFER_REPS,
1275                             i -> (int)(i + 1));
1276             }),
1277             withToString("int[i - 2]", (int s) -> {
1278                 return fill(s * BUFFER_REPS,
1279                             i -> (int)(i - 2));
1280             }),
1281             withToString("int[zigZag(i)]", (int s) -> {
1282                 return fill(s * BUFFER_REPS,
1283                             i -> i%3 == 0 ? (int)i : (i%3 == 1 ? (int)(i + 1) : (int)(i - 2)));
1284             }),
1285             withToString("int[cornerCaseValue(i)]", (int s) -> {
1286                 return fill(s * BUFFER_REPS,
1287                             i -> cornerCaseValue(i));
1288             })
1289     );
1290 
1291     static final List<List<IntFunction<int[]>>> INT_TEST_GENERATOR_ARGS =
1292         INT_COMPARE_GENERATORS.stream().
1293                 map(fa -> List.of(fa)).
1294                 collect(Collectors.toList());
1295 
1296     @DataProvider
1297     public Object[][] intTestOpProvider() {
1298         return INT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1299                 toArray(Object[][]::new);
1300     }
1301 
1302     @DataProvider
1303     public Object[][] intTestOpMaskProvider() {
1304         return BOOLEAN_MASK_GENERATORS.stream().
1305                 flatMap(fm -> INT_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1306                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1307                 })).
1308                 toArray(Object[][]::new);
1309     }
1310 
1311     static final List<List<IntFunction<int[]>>> INT_COMPARE_GENERATOR_PAIRS =
1312         INT_COMPARE_GENERATORS.stream().
1313                 flatMap(fa -> INT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1314                 collect(Collectors.toList());
1315 
1316     @DataProvider
1317     public Object[][] intCompareOpProvider() {
1318         return INT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1319                 toArray(Object[][]::new);
1320     }
1321 
1322     @DataProvider
1323     public Object[][] intCompareOpMaskProvider() {
1324         return BOOLEAN_MASK_GENERATORS.stream().
1325                 flatMap(fm -> INT_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1326                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1327                 })).
1328                 toArray(Object[][]::new);
1329     }
1330 
1331     interface ToIntF {
1332         int apply(int i);
1333     }
1334 
1335     static int[] fill(int s , ToIntF f) {
1336         return fill(new int[s], f);
1337     }
1338 
1339     static int[] fill(int[] a, ToIntF f) {
1340         for (int i = 0; i < a.length; i++) {
1341             a[i] = f.apply(i);
1342         }
1343         return a;
1344     }
1345 
1346     static int cornerCaseValue(int i) {
1347         switch(i % 5) {
1348             case 0:
1349                 return Integer.MAX_VALUE;
1350             case 1:
1351                 return Integer.MIN_VALUE;
1352             case 2:
1353                 return Integer.MIN_VALUE;
1354             case 3:
1355                 return Integer.MAX_VALUE;
1356             default:
1357                 return (int)0;
1358         }
1359     }
1360 
1361     static final IntFunction<int[]> fr = (vl) -> {
1362         int length = BUFFER_REPS * vl;
1363         return new int[length];
1364     };
1365 
1366     static final IntFunction<boolean[]> fmr = (vl) -> {
1367         int length = BUFFER_REPS * vl;
1368         return new boolean[length];
1369     };
1370 
1371     static final IntFunction<long[]> lfr = (vl) -> {
1372         int length = BUFFER_REPS * vl;
1373         return new long[length];
1374     };
1375 
1376     static void replaceZero(int[] a, int v) {
1377         for (int i = 0; i < a.length; i++) {
1378             if (a[i] == 0) {
1379                 a[i] = v;
1380             }
1381         }
1382     }
1383 
1384     static void replaceZero(int[] a, boolean[] mask, int v) {
1385         for (int i = 0; i < a.length; i++) {
1386             if (mask[i % mask.length] && a[i] == 0) {
1387                 a[i] = v;
1388             }
1389         }
1390     }
1391 
1392     static int ROL_scalar(int a, int b) {
1393         return Integer.rotateLeft(a, ((int)b));
1394     }
1395 
1396     static int ROR_scalar(int a, int b) {
1397         return Integer.rotateRight(a, ((int)b));
1398     }
1399 
1400     static int TRAILING_ZEROS_COUNT_scalar(int a) {
1401         return Integer.numberOfTrailingZeros(a);
1402     }
1403 
1404     static int LEADING_ZEROS_COUNT_scalar(int a) {
1405         return Integer.numberOfLeadingZeros(a);
1406     }
1407 
1408     static int REVERSE_scalar(int a) {
1409         return Integer.reverse(a);
1410     }
1411 
1412     static boolean eq(int a, int b) {
1413         return a == b;
1414     }
1415 
1416     static boolean neq(int a, int b) {
1417         return a != b;
1418     }
1419 
1420     static boolean lt(int a, int b) {
1421         return a < b;
1422     }
1423 
1424     static boolean le(int a, int b) {
1425         return a <= b;
1426     }
1427 
1428     static boolean gt(int a, int b) {
1429         return a > b;
1430     }
1431 
1432     static boolean ge(int a, int b) {
1433         return a >= b;
1434     }
1435 
1436     static boolean ult(int a, int b) {
1437         return Integer.compareUnsigned(a, b) < 0;
1438     }
1439 
1440     static boolean ule(int a, int b) {
1441         return Integer.compareUnsigned(a, b) <= 0;
1442     }
1443 
1444     static boolean ugt(int a, int b) {
1445         return Integer.compareUnsigned(a, b) > 0;
1446     }
1447 
1448     static boolean uge(int a, int b) {
1449         return Integer.compareUnsigned(a, b) >= 0;
1450     }
1451 
1452     static int firstNonZero(int a, int b) {
1453         return Integer.compare(a, (int) 0) != 0 ? a : b;
1454     }
1455 
1456     @Test
1457     static void smokeTest1() {
1458         IntVector three = IntVector.broadcast(SPECIES, (byte)-3);
1459         IntVector three2 = (IntVector) SPECIES.broadcast(-3);
1460         assert(three.eq(three2).allTrue());
1461         IntVector three3 = three2.broadcast(1).broadcast(-3);
1462         assert(three.eq(three3).allTrue());
1463         int scale = 2;
1464         Class<?> ETYPE = int.class;
1465         if (ETYPE == double.class || ETYPE == long.class)
1466             scale = 1000000;
1467         else if (ETYPE == byte.class && SPECIES.length() >= 64)
1468             scale = 1;
1469         IntVector higher = three.addIndex(scale);
1470         VectorMask<Integer> m = three.compare(VectorOperators.LE, higher);
1471         assert(m.allTrue());
1472         m = higher.min((int)-1).test(VectorOperators.IS_NEGATIVE);
1473         assert(m.allTrue());
1474         int max = higher.reduceLanes(VectorOperators.MAX);
1475         assert(max == -3 + scale * (SPECIES.length()-1));
1476     }
1477 
1478     private static int[]
1479     bothToArray(IntVector a, IntVector b) {
1480         int[] r = new int[a.length() + b.length()];
1481         a.intoArray(r, 0);
1482         b.intoArray(r, a.length());
1483         return r;
1484     }
1485 
1486     @Test
1487     static void smokeTest2() {
1488         // Do some zipping and shuffling.
1489         IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
1490         IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1491         Assert.assertEquals(io, io2);
1492         IntVector a = io.add((int)1); //[1,2]
1493         IntVector b = a.neg();  //[-1,-2]
1494         int[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1495         VectorShuffle<Integer> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1496         VectorShuffle<Integer> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1497         IntVector zab0 = a.rearrange(zip0,b); //[1,-1]
1498         IntVector zab1 = a.rearrange(zip1,b); //[2,-2]
1499         int[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1500         // manually zip
1501         int[] manual = new int[zabValues.length];
1502         for (int i = 0; i < manual.length; i += 2) {
1503             manual[i+0] = abValues[i/2];
1504             manual[i+1] = abValues[a.length() + i/2];
1505         }
1506         Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1507         VectorShuffle<Integer> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1508         VectorShuffle<Integer> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1509         IntVector uab0 = zab0.rearrange(unz0,zab1);
1510         IntVector uab1 = zab0.rearrange(unz1,zab1);
1511         int[] abValues1 = bothToArray(uab0, uab1);
1512         Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1513     }
1514 
1515     static void iotaShuffle() {
1516         IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
1517         IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1518         Assert.assertEquals(io, io2);
1519     }
1520 
1521     @Test
1522     // Test all shuffle related operations.
1523     static void shuffleTest() {
1524         // To test backend instructions, make sure that C2 is used.
1525         for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1526             iotaShuffle();
1527         }
1528     }
1529 
1530     @Test
1531     void viewAsIntegeralLanesTest() {
1532         Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1533         Assert.assertEquals(asIntegral.species(), SPECIES);
1534     }
1535 
1536     @Test
1537     void viewAsFloatingLanesTest() {
1538         Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
1539         VectorSpecies<?> asFloatingSpecies = asFloating.species();
1540         Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
1541         Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
1542         Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
1543         Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
1544     }
1545 
1546     @Test
1547     // Test div by 0.
1548     static void bitwiseDivByZeroSmokeTest() {
1549         try {
1550             IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
1551             IntVector b = (IntVector) SPECIES.broadcast(0);
1552             a.div(b);
1553             Assert.fail();
1554         } catch (ArithmeticException e) {
1555         }
1556 
1557         try {
1558             IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
1559             IntVector b = (IntVector) SPECIES.broadcast(0);
1560             VectorMask<Integer> m = a.lt((int) 1);
1561             a.div(b, m);
1562             Assert.fail();
1563         } catch (ArithmeticException e) {
1564         }
1565     }
1566 
1567     static int ADD(int a, int b) {
1568         return (int)(a + b);
1569     }
1570 
1571     @Test(dataProvider = "intBinaryOpProvider")
1572     static void ADDInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1573         int[] a = fa.apply(SPECIES.length());
1574         int[] b = fb.apply(SPECIES.length());
1575         int[] r = fr.apply(SPECIES.length());
1576 
1577         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1578             for (int i = 0; i < a.length; i += SPECIES.length()) {
1579                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1580                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1581                 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1582             }
1583         }
1584 
1585         assertArraysEquals(r, a, b, Int64VectorTests::ADD);
1586     }
1587 
1588     static int add(int a, int b) {
1589         return (int)(a + b);
1590     }
1591 
1592     @Test(dataProvider = "intBinaryOpProvider")
1593     static void addInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1594         int[] a = fa.apply(SPECIES.length());
1595         int[] b = fb.apply(SPECIES.length());
1596         int[] r = fr.apply(SPECIES.length());
1597 
1598         for (int i = 0; i < a.length; i += SPECIES.length()) {
1599             IntVector av = IntVector.fromArray(SPECIES, a, i);
1600             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1601             av.add(bv).intoArray(r, i);
1602         }
1603 
1604         assertArraysEquals(r, a, b, Int64VectorTests::add);
1605     }
1606 
1607     @Test(dataProvider = "intBinaryOpMaskProvider")
1608     static void ADDInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1609                                           IntFunction<boolean[]> fm) {
1610         int[] a = fa.apply(SPECIES.length());
1611         int[] b = fb.apply(SPECIES.length());
1612         int[] r = fr.apply(SPECIES.length());
1613         boolean[] mask = fm.apply(SPECIES.length());
1614         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1615 
1616         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1617             for (int i = 0; i < a.length; i += SPECIES.length()) {
1618                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1619                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1620                 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1621             }
1622         }
1623 
1624         assertArraysEquals(r, a, b, mask, Int64VectorTests::ADD);
1625     }
1626 
1627     @Test(dataProvider = "intBinaryOpMaskProvider")
1628     static void addInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1629                                           IntFunction<boolean[]> fm) {
1630         int[] a = fa.apply(SPECIES.length());
1631         int[] b = fb.apply(SPECIES.length());
1632         int[] r = fr.apply(SPECIES.length());
1633         boolean[] mask = fm.apply(SPECIES.length());
1634         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1635 
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.add(bv, vmask).intoArray(r, i);
1640         }
1641 
1642         assertArraysEquals(r, a, b, mask, Int64VectorTests::add);
1643     }
1644 
1645     static int SUB(int a, int b) {
1646         return (int)(a - b);
1647     }
1648 
1649     @Test(dataProvider = "intBinaryOpProvider")
1650     static void SUBInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1651         int[] a = fa.apply(SPECIES.length());
1652         int[] b = fb.apply(SPECIES.length());
1653         int[] r = fr.apply(SPECIES.length());
1654 
1655         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1656             for (int i = 0; i < a.length; i += SPECIES.length()) {
1657                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1658                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1659                 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1660             }
1661         }
1662 
1663         assertArraysEquals(r, a, b, Int64VectorTests::SUB);
1664     }
1665 
1666     static int sub(int a, int b) {
1667         return (int)(a - b);
1668     }
1669 
1670     @Test(dataProvider = "intBinaryOpProvider")
1671     static void subInt64VectorTests(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.sub(bv).intoArray(r, i);
1680         }
1681 
1682         assertArraysEquals(r, a, b, Int64VectorTests::sub);
1683     }
1684 
1685     @Test(dataProvider = "intBinaryOpMaskProvider")
1686     static void SUBInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1687                                           IntFunction<boolean[]> fm) {
1688         int[] a = fa.apply(SPECIES.length());
1689         int[] b = fb.apply(SPECIES.length());
1690         int[] r = fr.apply(SPECIES.length());
1691         boolean[] mask = fm.apply(SPECIES.length());
1692         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1693 
1694         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1695             for (int i = 0; i < a.length; i += SPECIES.length()) {
1696                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1697                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1698                 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1699             }
1700         }
1701 
1702         assertArraysEquals(r, a, b, mask, Int64VectorTests::SUB);
1703     }
1704 
1705     @Test(dataProvider = "intBinaryOpMaskProvider")
1706     static void subInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1707                                           IntFunction<boolean[]> fm) {
1708         int[] a = fa.apply(SPECIES.length());
1709         int[] b = fb.apply(SPECIES.length());
1710         int[] r = fr.apply(SPECIES.length());
1711         boolean[] mask = fm.apply(SPECIES.length());
1712         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1713 
1714         for (int i = 0; i < a.length; i += SPECIES.length()) {
1715             IntVector av = IntVector.fromArray(SPECIES, a, i);
1716             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1717             av.sub(bv, vmask).intoArray(r, i);
1718         }
1719 
1720         assertArraysEquals(r, a, b, mask, Int64VectorTests::sub);
1721     }
1722 
1723     static int MUL(int a, int b) {
1724         return (int)(a * b);
1725     }
1726 
1727     @Test(dataProvider = "intBinaryOpProvider")
1728     static void MULInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1729         int[] a = fa.apply(SPECIES.length());
1730         int[] b = fb.apply(SPECIES.length());
1731         int[] r = fr.apply(SPECIES.length());
1732 
1733         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1734             for (int i = 0; i < a.length; i += SPECIES.length()) {
1735                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1736                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1737                 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1738             }
1739         }
1740 
1741         assertArraysEquals(r, a, b, Int64VectorTests::MUL);
1742     }
1743 
1744     static int mul(int a, int b) {
1745         return (int)(a * b);
1746     }
1747 
1748     @Test(dataProvider = "intBinaryOpProvider")
1749     static void mulInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1750         int[] a = fa.apply(SPECIES.length());
1751         int[] b = fb.apply(SPECIES.length());
1752         int[] r = fr.apply(SPECIES.length());
1753 
1754         for (int i = 0; i < a.length; i += SPECIES.length()) {
1755             IntVector av = IntVector.fromArray(SPECIES, a, i);
1756             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1757             av.mul(bv).intoArray(r, i);
1758         }
1759 
1760         assertArraysEquals(r, a, b, Int64VectorTests::mul);
1761     }
1762 
1763     @Test(dataProvider = "intBinaryOpMaskProvider")
1764     static void MULInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1765                                           IntFunction<boolean[]> fm) {
1766         int[] a = fa.apply(SPECIES.length());
1767         int[] b = fb.apply(SPECIES.length());
1768         int[] r = fr.apply(SPECIES.length());
1769         boolean[] mask = fm.apply(SPECIES.length());
1770         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1771 
1772         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1773             for (int i = 0; i < a.length; i += SPECIES.length()) {
1774                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1775                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1776                 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1777             }
1778         }
1779 
1780         assertArraysEquals(r, a, b, mask, Int64VectorTests::MUL);
1781     }
1782 
1783     @Test(dataProvider = "intBinaryOpMaskProvider")
1784     static void mulInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1785                                           IntFunction<boolean[]> fm) {
1786         int[] a = fa.apply(SPECIES.length());
1787         int[] b = fb.apply(SPECIES.length());
1788         int[] r = fr.apply(SPECIES.length());
1789         boolean[] mask = fm.apply(SPECIES.length());
1790         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1791 
1792         for (int i = 0; i < a.length; i += SPECIES.length()) {
1793             IntVector av = IntVector.fromArray(SPECIES, a, i);
1794             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1795             av.mul(bv, vmask).intoArray(r, i);
1796         }
1797 
1798         assertArraysEquals(r, a, b, mask, Int64VectorTests::mul);
1799     }
1800 
1801     static int DIV(int a, int b) {
1802         return (int)(a / b);
1803     }
1804 
1805     @Test(dataProvider = "intBinaryOpProvider")
1806     static void DIVInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1807         int[] a = fa.apply(SPECIES.length());
1808         int[] b = fb.apply(SPECIES.length());
1809         int[] r = fr.apply(SPECIES.length());
1810 
1811         replaceZero(b, (int) 1);
1812 
1813         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1814             for (int i = 0; i < a.length; i += SPECIES.length()) {
1815                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1816                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1817                 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1818             }
1819         }
1820 
1821         assertArraysEquals(r, a, b, Int64VectorTests::DIV);
1822     }
1823 
1824     static int div(int a, int b) {
1825         return (int)(a / b);
1826     }
1827 
1828     @Test(dataProvider = "intBinaryOpProvider")
1829     static void divInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1830         int[] a = fa.apply(SPECIES.length());
1831         int[] b = fb.apply(SPECIES.length());
1832         int[] r = fr.apply(SPECIES.length());
1833 
1834         replaceZero(b, (int) 1);
1835 
1836         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1837             for (int i = 0; i < a.length; i += SPECIES.length()) {
1838                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1839                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1840                 av.div(bv).intoArray(r, i);
1841             }
1842         }
1843 
1844         assertArraysEquals(r, a, b, Int64VectorTests::div);
1845     }
1846 
1847     @Test(dataProvider = "intBinaryOpMaskProvider")
1848     static void DIVInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1849                                           IntFunction<boolean[]> fm) {
1850         int[] a = fa.apply(SPECIES.length());
1851         int[] b = fb.apply(SPECIES.length());
1852         int[] r = fr.apply(SPECIES.length());
1853         boolean[] mask = fm.apply(SPECIES.length());
1854         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1855 
1856         replaceZero(b, mask, (int) 1);
1857 
1858         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1859             for (int i = 0; i < a.length; i += SPECIES.length()) {
1860                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1861                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1862                 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1863             }
1864         }
1865 
1866         assertArraysEquals(r, a, b, mask, Int64VectorTests::DIV);
1867     }
1868 
1869     @Test(dataProvider = "intBinaryOpMaskProvider")
1870     static void divInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1871                                           IntFunction<boolean[]> fm) {
1872         int[] a = fa.apply(SPECIES.length());
1873         int[] b = fb.apply(SPECIES.length());
1874         int[] r = fr.apply(SPECIES.length());
1875         boolean[] mask = fm.apply(SPECIES.length());
1876         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1877 
1878         replaceZero(b, mask, (int) 1);
1879 
1880         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1881             for (int i = 0; i < a.length; i += SPECIES.length()) {
1882                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1883                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1884                 av.div(bv, vmask).intoArray(r, i);
1885             }
1886         }
1887 
1888         assertArraysEquals(r, a, b, mask, Int64VectorTests::div);
1889     }
1890 
1891     static int FIRST_NONZERO(int a, int b) {
1892         return (int)((a)!=0?a:b);
1893     }
1894 
1895     @Test(dataProvider = "intBinaryOpProvider")
1896     static void FIRST_NONZEROInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1897         int[] a = fa.apply(SPECIES.length());
1898         int[] b = fb.apply(SPECIES.length());
1899         int[] r = fr.apply(SPECIES.length());
1900 
1901         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1902             for (int i = 0; i < a.length; i += SPECIES.length()) {
1903                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1904                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1905                 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1906             }
1907         }
1908 
1909         assertArraysEquals(r, a, b, Int64VectorTests::FIRST_NONZERO);
1910     }
1911 
1912     @Test(dataProvider = "intBinaryOpMaskProvider")
1913     static void FIRST_NONZEROInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1914                                           IntFunction<boolean[]> fm) {
1915         int[] a = fa.apply(SPECIES.length());
1916         int[] b = fb.apply(SPECIES.length());
1917         int[] r = fr.apply(SPECIES.length());
1918         boolean[] mask = fm.apply(SPECIES.length());
1919         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1920 
1921         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1922             for (int i = 0; i < a.length; i += SPECIES.length()) {
1923                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1924                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1925                 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1926             }
1927         }
1928 
1929         assertArraysEquals(r, a, b, mask, Int64VectorTests::FIRST_NONZERO);
1930     }
1931 
1932     static int AND(int a, int b) {
1933         return (int)(a & b);
1934     }
1935 
1936     @Test(dataProvider = "intBinaryOpProvider")
1937     static void ANDInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1938         int[] a = fa.apply(SPECIES.length());
1939         int[] b = fb.apply(SPECIES.length());
1940         int[] r = fr.apply(SPECIES.length());
1941 
1942         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1943             for (int i = 0; i < a.length; i += SPECIES.length()) {
1944                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1945                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1946                 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1947             }
1948         }
1949 
1950         assertArraysEquals(r, a, b, Int64VectorTests::AND);
1951     }
1952 
1953     static int and(int a, int b) {
1954         return (int)(a & b);
1955     }
1956 
1957     @Test(dataProvider = "intBinaryOpProvider")
1958     static void andInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1959         int[] a = fa.apply(SPECIES.length());
1960         int[] b = fb.apply(SPECIES.length());
1961         int[] r = fr.apply(SPECIES.length());
1962 
1963         for (int i = 0; i < a.length; i += SPECIES.length()) {
1964             IntVector av = IntVector.fromArray(SPECIES, a, i);
1965             IntVector bv = IntVector.fromArray(SPECIES, b, i);
1966             av.and(bv).intoArray(r, i);
1967         }
1968 
1969         assertArraysEquals(r, a, b, Int64VectorTests::and);
1970     }
1971 
1972     @Test(dataProvider = "intBinaryOpMaskProvider")
1973     static void ANDInt64VectorTestsMasked(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         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1982             for (int i = 0; i < a.length; i += SPECIES.length()) {
1983                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1984                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1985                 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1986             }
1987         }
1988 
1989         assertArraysEquals(r, a, b, mask, Int64VectorTests::AND);
1990     }
1991 
1992     static int AND_NOT(int a, int b) {
1993         return (int)(a & ~b);
1994     }
1995 
1996     @Test(dataProvider = "intBinaryOpProvider")
1997     static void AND_NOTInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1998         int[] a = fa.apply(SPECIES.length());
1999         int[] b = fb.apply(SPECIES.length());
2000         int[] r = fr.apply(SPECIES.length());
2001 
2002         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2003             for (int i = 0; i < a.length; i += SPECIES.length()) {
2004                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2005                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2006                 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
2007             }
2008         }
2009 
2010         assertArraysEquals(r, a, b, Int64VectorTests::AND_NOT);
2011     }
2012 
2013     @Test(dataProvider = "intBinaryOpMaskProvider")
2014     static void AND_NOTInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2015                                           IntFunction<boolean[]> fm) {
2016         int[] a = fa.apply(SPECIES.length());
2017         int[] b = fb.apply(SPECIES.length());
2018         int[] r = fr.apply(SPECIES.length());
2019         boolean[] mask = fm.apply(SPECIES.length());
2020         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2021 
2022         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2023             for (int i = 0; i < a.length; i += SPECIES.length()) {
2024                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2025                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2026                 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
2027             }
2028         }
2029 
2030         assertArraysEquals(r, a, b, mask, Int64VectorTests::AND_NOT);
2031     }
2032 
2033     static int OR(int a, int b) {
2034         return (int)(a | b);
2035     }
2036 
2037     @Test(dataProvider = "intBinaryOpProvider")
2038     static void ORInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2039         int[] a = fa.apply(SPECIES.length());
2040         int[] b = fb.apply(SPECIES.length());
2041         int[] r = fr.apply(SPECIES.length());
2042 
2043         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2044             for (int i = 0; i < a.length; i += SPECIES.length()) {
2045                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2046                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2047                 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
2048             }
2049         }
2050 
2051         assertArraysEquals(r, a, b, Int64VectorTests::OR);
2052     }
2053 
2054     static int or(int a, int b) {
2055         return (int)(a | b);
2056     }
2057 
2058     @Test(dataProvider = "intBinaryOpProvider")
2059     static void orInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2060         int[] a = fa.apply(SPECIES.length());
2061         int[] b = fb.apply(SPECIES.length());
2062         int[] r = fr.apply(SPECIES.length());
2063 
2064         for (int i = 0; i < a.length; i += SPECIES.length()) {
2065             IntVector av = IntVector.fromArray(SPECIES, a, i);
2066             IntVector bv = IntVector.fromArray(SPECIES, b, i);
2067             av.or(bv).intoArray(r, i);
2068         }
2069 
2070         assertArraysEquals(r, a, b, Int64VectorTests::or);
2071     }
2072 
2073     @Test(dataProvider = "intBinaryOpMaskProvider")
2074     static void ORInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2075                                           IntFunction<boolean[]> fm) {
2076         int[] a = fa.apply(SPECIES.length());
2077         int[] b = fb.apply(SPECIES.length());
2078         int[] r = fr.apply(SPECIES.length());
2079         boolean[] mask = fm.apply(SPECIES.length());
2080         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2081 
2082         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2083             for (int i = 0; i < a.length; i += SPECIES.length()) {
2084                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2085                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2086                 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
2087             }
2088         }
2089 
2090         assertArraysEquals(r, a, b, mask, Int64VectorTests::OR);
2091     }
2092 
2093     static int XOR(int a, int b) {
2094         return (int)(a ^ b);
2095     }
2096 
2097     @Test(dataProvider = "intBinaryOpProvider")
2098     static void XORInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2099         int[] a = fa.apply(SPECIES.length());
2100         int[] b = fb.apply(SPECIES.length());
2101         int[] r = fr.apply(SPECIES.length());
2102 
2103         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2104             for (int i = 0; i < a.length; i += SPECIES.length()) {
2105                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2106                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2107                 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
2108             }
2109         }
2110 
2111         assertArraysEquals(r, a, b, Int64VectorTests::XOR);
2112     }
2113 
2114     @Test(dataProvider = "intBinaryOpMaskProvider")
2115     static void XORInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2116                                           IntFunction<boolean[]> fm) {
2117         int[] a = fa.apply(SPECIES.length());
2118         int[] b = fb.apply(SPECIES.length());
2119         int[] r = fr.apply(SPECIES.length());
2120         boolean[] mask = fm.apply(SPECIES.length());
2121         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2122 
2123         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2124             for (int i = 0; i < a.length; i += SPECIES.length()) {
2125                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2126                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2127                 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
2128             }
2129         }
2130 
2131         assertArraysEquals(r, a, b, mask, Int64VectorTests::XOR);
2132     }
2133 
2134     static int COMPRESS_BITS(int a, int b) {
2135         return (int)(Integer.compress(a, b));
2136     }
2137 
2138     @Test(dataProvider = "intBinaryOpProvider")
2139     static void COMPRESS_BITSInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2140         int[] a = fa.apply(SPECIES.length());
2141         int[] b = fb.apply(SPECIES.length());
2142         int[] r = fr.apply(SPECIES.length());
2143 
2144         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2145             for (int i = 0; i < a.length; i += SPECIES.length()) {
2146                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2147                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2148                 av.lanewise(VectorOperators.COMPRESS_BITS, bv).intoArray(r, i);
2149             }
2150         }
2151 
2152         assertArraysEquals(r, a, b, Int64VectorTests::COMPRESS_BITS);
2153     }
2154 
2155     @Test(dataProvider = "intBinaryOpMaskProvider")
2156     static void COMPRESS_BITSInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2157                                           IntFunction<boolean[]> fm) {
2158         int[] a = fa.apply(SPECIES.length());
2159         int[] b = fb.apply(SPECIES.length());
2160         int[] r = fr.apply(SPECIES.length());
2161         boolean[] mask = fm.apply(SPECIES.length());
2162         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2163 
2164         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2165             for (int i = 0; i < a.length; i += SPECIES.length()) {
2166                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2167                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2168                 av.lanewise(VectorOperators.COMPRESS_BITS, bv, vmask).intoArray(r, i);
2169             }
2170         }
2171 
2172         assertArraysEquals(r, a, b, mask, Int64VectorTests::COMPRESS_BITS);
2173     }
2174 
2175     static int EXPAND_BITS(int a, int b) {
2176         return (int)(Integer.expand(a, b));
2177     }
2178 
2179     @Test(dataProvider = "intBinaryOpProvider")
2180     static void EXPAND_BITSInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2181         int[] a = fa.apply(SPECIES.length());
2182         int[] b = fb.apply(SPECIES.length());
2183         int[] r = fr.apply(SPECIES.length());
2184 
2185         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2186             for (int i = 0; i < a.length; i += SPECIES.length()) {
2187                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2188                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2189                 av.lanewise(VectorOperators.EXPAND_BITS, bv).intoArray(r, i);
2190             }
2191         }
2192 
2193         assertArraysEquals(r, a, b, Int64VectorTests::EXPAND_BITS);
2194     }
2195 
2196     @Test(dataProvider = "intBinaryOpMaskProvider")
2197     static void EXPAND_BITSInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2198                                           IntFunction<boolean[]> fm) {
2199         int[] a = fa.apply(SPECIES.length());
2200         int[] b = fb.apply(SPECIES.length());
2201         int[] r = fr.apply(SPECIES.length());
2202         boolean[] mask = fm.apply(SPECIES.length());
2203         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2204 
2205         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2206             for (int i = 0; i < a.length; i += SPECIES.length()) {
2207                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2208                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2209                 av.lanewise(VectorOperators.EXPAND_BITS, bv, vmask).intoArray(r, i);
2210             }
2211         }
2212 
2213         assertArraysEquals(r, a, b, mask, Int64VectorTests::EXPAND_BITS);
2214     }
2215 
2216     @Test(dataProvider = "intBinaryOpProvider")
2217     static void addInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2218         int[] a = fa.apply(SPECIES.length());
2219         int[] b = fb.apply(SPECIES.length());
2220         int[] r = fr.apply(SPECIES.length());
2221 
2222         for (int i = 0; i < a.length; i += SPECIES.length()) {
2223             IntVector av = IntVector.fromArray(SPECIES, a, i);
2224             av.add(b[i]).intoArray(r, i);
2225         }
2226 
2227         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::add);
2228     }
2229 
2230     @Test(dataProvider = "intBinaryOpMaskProvider")
2231     static void addInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2232                                           IntFunction<boolean[]> fm) {
2233         int[] a = fa.apply(SPECIES.length());
2234         int[] b = fb.apply(SPECIES.length());
2235         int[] r = fr.apply(SPECIES.length());
2236         boolean[] mask = fm.apply(SPECIES.length());
2237         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2238 
2239         for (int i = 0; i < a.length; i += SPECIES.length()) {
2240             IntVector av = IntVector.fromArray(SPECIES, a, i);
2241             av.add(b[i], vmask).intoArray(r, i);
2242         }
2243 
2244         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::add);
2245     }
2246 
2247     @Test(dataProvider = "intBinaryOpProvider")
2248     static void subInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2249         int[] a = fa.apply(SPECIES.length());
2250         int[] b = fb.apply(SPECIES.length());
2251         int[] r = fr.apply(SPECIES.length());
2252 
2253         for (int i = 0; i < a.length; i += SPECIES.length()) {
2254             IntVector av = IntVector.fromArray(SPECIES, a, i);
2255             av.sub(b[i]).intoArray(r, i);
2256         }
2257 
2258         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::sub);
2259     }
2260 
2261     @Test(dataProvider = "intBinaryOpMaskProvider")
2262     static void subInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2263                                           IntFunction<boolean[]> fm) {
2264         int[] a = fa.apply(SPECIES.length());
2265         int[] b = fb.apply(SPECIES.length());
2266         int[] r = fr.apply(SPECIES.length());
2267         boolean[] mask = fm.apply(SPECIES.length());
2268         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2269 
2270         for (int i = 0; i < a.length; i += SPECIES.length()) {
2271             IntVector av = IntVector.fromArray(SPECIES, a, i);
2272             av.sub(b[i], vmask).intoArray(r, i);
2273         }
2274 
2275         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::sub);
2276     }
2277 
2278     @Test(dataProvider = "intBinaryOpProvider")
2279     static void mulInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2280         int[] a = fa.apply(SPECIES.length());
2281         int[] b = fb.apply(SPECIES.length());
2282         int[] r = fr.apply(SPECIES.length());
2283 
2284         for (int i = 0; i < a.length; i += SPECIES.length()) {
2285             IntVector av = IntVector.fromArray(SPECIES, a, i);
2286             av.mul(b[i]).intoArray(r, i);
2287         }
2288 
2289         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::mul);
2290     }
2291 
2292     @Test(dataProvider = "intBinaryOpMaskProvider")
2293     static void mulInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2294                                           IntFunction<boolean[]> fm) {
2295         int[] a = fa.apply(SPECIES.length());
2296         int[] b = fb.apply(SPECIES.length());
2297         int[] r = fr.apply(SPECIES.length());
2298         boolean[] mask = fm.apply(SPECIES.length());
2299         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2300 
2301         for (int i = 0; i < a.length; i += SPECIES.length()) {
2302             IntVector av = IntVector.fromArray(SPECIES, a, i);
2303             av.mul(b[i], vmask).intoArray(r, i);
2304         }
2305 
2306         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::mul);
2307     }
2308 
2309     @Test(dataProvider = "intBinaryOpProvider")
2310     static void divInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2311         int[] a = fa.apply(SPECIES.length());
2312         int[] b = fb.apply(SPECIES.length());
2313         int[] r = fr.apply(SPECIES.length());
2314 
2315         replaceZero(b, (int) 1);
2316 
2317         for (int i = 0; i < a.length; i += SPECIES.length()) {
2318             IntVector av = IntVector.fromArray(SPECIES, a, i);
2319             av.div(b[i]).intoArray(r, i);
2320         }
2321 
2322         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::div);
2323     }
2324 
2325     @Test(dataProvider = "intBinaryOpMaskProvider")
2326     static void divInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2327                                           IntFunction<boolean[]> fm) {
2328         int[] a = fa.apply(SPECIES.length());
2329         int[] b = fb.apply(SPECIES.length());
2330         int[] r = fr.apply(SPECIES.length());
2331         boolean[] mask = fm.apply(SPECIES.length());
2332         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2333 
2334         replaceZero(b, (int) 1);
2335 
2336         for (int i = 0; i < a.length; i += SPECIES.length()) {
2337             IntVector av = IntVector.fromArray(SPECIES, a, i);
2338             av.div(b[i], vmask).intoArray(r, i);
2339         }
2340 
2341         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::div);
2342     }
2343 
2344     @Test(dataProvider = "intBinaryOpProvider")
2345     static void ORInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2346         int[] a = fa.apply(SPECIES.length());
2347         int[] b = fb.apply(SPECIES.length());
2348         int[] r = fr.apply(SPECIES.length());
2349 
2350         for (int i = 0; i < a.length; i += SPECIES.length()) {
2351             IntVector av = IntVector.fromArray(SPECIES, a, i);
2352             av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
2353         }
2354 
2355         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::OR);
2356     }
2357 
2358     @Test(dataProvider = "intBinaryOpProvider")
2359     static void orInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2360         int[] a = fa.apply(SPECIES.length());
2361         int[] b = fb.apply(SPECIES.length());
2362         int[] r = fr.apply(SPECIES.length());
2363 
2364         for (int i = 0; i < a.length; i += SPECIES.length()) {
2365             IntVector av = IntVector.fromArray(SPECIES, a, i);
2366             av.or(b[i]).intoArray(r, i);
2367         }
2368 
2369         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::or);
2370     }
2371 
2372     @Test(dataProvider = "intBinaryOpMaskProvider")
2373     static void ORInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2374                                           IntFunction<boolean[]> fm) {
2375         int[] a = fa.apply(SPECIES.length());
2376         int[] b = fb.apply(SPECIES.length());
2377         int[] r = fr.apply(SPECIES.length());
2378         boolean[] mask = fm.apply(SPECIES.length());
2379         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2380 
2381         for (int i = 0; i < a.length; i += SPECIES.length()) {
2382             IntVector av = IntVector.fromArray(SPECIES, a, i);
2383             av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
2384         }
2385 
2386         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::OR);
2387     }
2388 
2389     @Test(dataProvider = "intBinaryOpProvider")
2390     static void ANDInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2391         int[] a = fa.apply(SPECIES.length());
2392         int[] b = fb.apply(SPECIES.length());
2393         int[] r = fr.apply(SPECIES.length());
2394 
2395         for (int i = 0; i < a.length; i += SPECIES.length()) {
2396             IntVector av = IntVector.fromArray(SPECIES, a, i);
2397             av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
2398         }
2399 
2400         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::AND);
2401     }
2402 
2403     @Test(dataProvider = "intBinaryOpProvider")
2404     static void andInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2405         int[] a = fa.apply(SPECIES.length());
2406         int[] b = fb.apply(SPECIES.length());
2407         int[] r = fr.apply(SPECIES.length());
2408 
2409         for (int i = 0; i < a.length; i += SPECIES.length()) {
2410             IntVector av = IntVector.fromArray(SPECIES, a, i);
2411             av.and(b[i]).intoArray(r, i);
2412         }
2413 
2414         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::and);
2415     }
2416 
2417     @Test(dataProvider = "intBinaryOpMaskProvider")
2418     static void ANDInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2419                                           IntFunction<boolean[]> fm) {
2420         int[] a = fa.apply(SPECIES.length());
2421         int[] b = fb.apply(SPECIES.length());
2422         int[] r = fr.apply(SPECIES.length());
2423         boolean[] mask = fm.apply(SPECIES.length());
2424         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2425 
2426         for (int i = 0; i < a.length; i += SPECIES.length()) {
2427             IntVector av = IntVector.fromArray(SPECIES, a, i);
2428             av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
2429         }
2430 
2431         assertBroadcastArraysEquals(r, a, b, mask, Int64VectorTests::AND);
2432     }
2433 
2434     @Test(dataProvider = "intBinaryOpProvider")
2435     static void ORInt64VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2436         int[] a = fa.apply(SPECIES.length());
2437         int[] b = fb.apply(SPECIES.length());
2438         int[] r = fr.apply(SPECIES.length());
2439 
2440         for (int i = 0; i < a.length; i += SPECIES.length()) {
2441             IntVector av = IntVector.fromArray(SPECIES, a, i);
2442             av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
2443         }
2444 
2445         assertBroadcastLongArraysEquals(r, a, b, Int64VectorTests::OR);
2446     }
2447 
2448     @Test(dataProvider = "intBinaryOpMaskProvider")
2449     static void ORInt64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2450                                           IntFunction<boolean[]> fm) {
2451         int[] a = fa.apply(SPECIES.length());
2452         int[] b = fb.apply(SPECIES.length());
2453         int[] r = fr.apply(SPECIES.length());
2454         boolean[] mask = fm.apply(SPECIES.length());
2455         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2456 
2457         for (int i = 0; i < a.length; i += SPECIES.length()) {
2458             IntVector av = IntVector.fromArray(SPECIES, a, i);
2459             av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
2460         }
2461 
2462         assertBroadcastLongArraysEquals(r, a, b, mask, Int64VectorTests::OR);
2463     }
2464 
2465     @Test(dataProvider = "intBinaryOpProvider")
2466     static void ADDInt64VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2467         int[] a = fa.apply(SPECIES.length());
2468         int[] b = fb.apply(SPECIES.length());
2469         int[] r = fr.apply(SPECIES.length());
2470 
2471         for (int i = 0; i < a.length; i += SPECIES.length()) {
2472             IntVector av = IntVector.fromArray(SPECIES, a, i);
2473             av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2474         }
2475 
2476         assertBroadcastLongArraysEquals(r, a, b, Int64VectorTests::ADD);
2477     }
2478 
2479     @Test(dataProvider = "intBinaryOpMaskProvider")
2480     static void ADDInt64VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2481                                           IntFunction<boolean[]> fm) {
2482         int[] a = fa.apply(SPECIES.length());
2483         int[] b = fb.apply(SPECIES.length());
2484         int[] r = fr.apply(SPECIES.length());
2485         boolean[] mask = fm.apply(SPECIES.length());
2486         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2487 
2488         for (int i = 0; i < a.length; i += SPECIES.length()) {
2489             IntVector av = IntVector.fromArray(SPECIES, a, i);
2490             av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2491         }
2492 
2493         assertBroadcastLongArraysEquals(r, a, b, mask, Int64VectorTests::ADD);
2494     }
2495 
2496     static int LSHL(int a, int b) {
2497         return (int)((a << b));
2498     }
2499 
2500     @Test(dataProvider = "intBinaryOpProvider")
2501     static void LSHLInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2502         int[] a = fa.apply(SPECIES.length());
2503         int[] b = fb.apply(SPECIES.length());
2504         int[] r = fr.apply(SPECIES.length());
2505 
2506         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2507             for (int i = 0; i < a.length; i += SPECIES.length()) {
2508                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2509                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2510                 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
2511             }
2512         }
2513 
2514         assertArraysEquals(r, a, b, Int64VectorTests::LSHL);
2515     }
2516 
2517     @Test(dataProvider = "intBinaryOpMaskProvider")
2518     static void LSHLInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2519                                           IntFunction<boolean[]> fm) {
2520         int[] a = fa.apply(SPECIES.length());
2521         int[] b = fb.apply(SPECIES.length());
2522         int[] r = fr.apply(SPECIES.length());
2523         boolean[] mask = fm.apply(SPECIES.length());
2524         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2525 
2526         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2527             for (int i = 0; i < a.length; i += SPECIES.length()) {
2528                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2529                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2530                 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
2531             }
2532         }
2533 
2534         assertArraysEquals(r, a, b, mask, Int64VectorTests::LSHL);
2535     }
2536 
2537     static int ASHR(int a, int b) {
2538         return (int)((a >> b));
2539     }
2540 
2541     @Test(dataProvider = "intBinaryOpProvider")
2542     static void ASHRInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2543         int[] a = fa.apply(SPECIES.length());
2544         int[] b = fb.apply(SPECIES.length());
2545         int[] r = fr.apply(SPECIES.length());
2546 
2547         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2548             for (int i = 0; i < a.length; i += SPECIES.length()) {
2549                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2550                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2551                 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
2552             }
2553         }
2554 
2555         assertArraysEquals(r, a, b, Int64VectorTests::ASHR);
2556     }
2557 
2558     @Test(dataProvider = "intBinaryOpMaskProvider")
2559     static void ASHRInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2560                                           IntFunction<boolean[]> fm) {
2561         int[] a = fa.apply(SPECIES.length());
2562         int[] b = fb.apply(SPECIES.length());
2563         int[] r = fr.apply(SPECIES.length());
2564         boolean[] mask = fm.apply(SPECIES.length());
2565         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2566 
2567         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2568             for (int i = 0; i < a.length; i += SPECIES.length()) {
2569                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2570                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2571                 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
2572             }
2573         }
2574 
2575         assertArraysEquals(r, a, b, mask, Int64VectorTests::ASHR);
2576     }
2577 
2578     static int LSHR(int a, int b) {
2579         return (int)((a >>> b));
2580     }
2581 
2582     @Test(dataProvider = "intBinaryOpProvider")
2583     static void LSHRInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2584         int[] a = fa.apply(SPECIES.length());
2585         int[] b = fb.apply(SPECIES.length());
2586         int[] r = fr.apply(SPECIES.length());
2587 
2588         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2589             for (int i = 0; i < a.length; i += SPECIES.length()) {
2590                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2591                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2592                 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
2593             }
2594         }
2595 
2596         assertArraysEquals(r, a, b, Int64VectorTests::LSHR);
2597     }
2598 
2599     @Test(dataProvider = "intBinaryOpMaskProvider")
2600     static void LSHRInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2601                                           IntFunction<boolean[]> fm) {
2602         int[] a = fa.apply(SPECIES.length());
2603         int[] b = fb.apply(SPECIES.length());
2604         int[] r = fr.apply(SPECIES.length());
2605         boolean[] mask = fm.apply(SPECIES.length());
2606         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2607 
2608         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2609             for (int i = 0; i < a.length; i += SPECIES.length()) {
2610                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2611                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2612                 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
2613             }
2614         }
2615 
2616         assertArraysEquals(r, a, b, mask, Int64VectorTests::LSHR);
2617     }
2618 
2619     static int LSHL_unary(int a, int b) {
2620         return (int)((a << b));
2621     }
2622 
2623     @Test(dataProvider = "intBinaryOpProvider")
2624     static void LSHLInt64VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2625         int[] a = fa.apply(SPECIES.length());
2626         int[] b = fb.apply(SPECIES.length());
2627         int[] r = fr.apply(SPECIES.length());
2628 
2629         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2630             for (int i = 0; i < a.length; i += SPECIES.length()) {
2631                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2632                 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
2633             }
2634         }
2635 
2636         assertShiftArraysEquals(r, a, b, Int64VectorTests::LSHL_unary);
2637     }
2638 
2639     @Test(dataProvider = "intBinaryOpMaskProvider")
2640     static void LSHLInt64VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2641                                           IntFunction<boolean[]> fm) {
2642         int[] a = fa.apply(SPECIES.length());
2643         int[] b = fb.apply(SPECIES.length());
2644         int[] r = fr.apply(SPECIES.length());
2645         boolean[] mask = fm.apply(SPECIES.length());
2646         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2647 
2648         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2649             for (int i = 0; i < a.length; i += SPECIES.length()) {
2650                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2651                 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
2652             }
2653         }
2654 
2655         assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::LSHL_unary);
2656     }
2657 
2658     static int LSHR_unary(int a, int b) {
2659         return (int)((a >>> b));
2660     }
2661 
2662     @Test(dataProvider = "intBinaryOpProvider")
2663     static void LSHRInt64VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2664         int[] a = fa.apply(SPECIES.length());
2665         int[] b = fb.apply(SPECIES.length());
2666         int[] r = fr.apply(SPECIES.length());
2667 
2668         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2669             for (int i = 0; i < a.length; i += SPECIES.length()) {
2670                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2671                 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
2672             }
2673         }
2674 
2675         assertShiftArraysEquals(r, a, b, Int64VectorTests::LSHR_unary);
2676     }
2677 
2678     @Test(dataProvider = "intBinaryOpMaskProvider")
2679     static void LSHRInt64VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2680                                           IntFunction<boolean[]> fm) {
2681         int[] a = fa.apply(SPECIES.length());
2682         int[] b = fb.apply(SPECIES.length());
2683         int[] r = fr.apply(SPECIES.length());
2684         boolean[] mask = fm.apply(SPECIES.length());
2685         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2686 
2687         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2688             for (int i = 0; i < a.length; i += SPECIES.length()) {
2689                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2690                 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
2691             }
2692         }
2693 
2694         assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::LSHR_unary);
2695     }
2696 
2697     static int ASHR_unary(int a, int b) {
2698         return (int)((a >> b));
2699     }
2700 
2701     @Test(dataProvider = "intBinaryOpProvider")
2702     static void ASHRInt64VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2703         int[] a = fa.apply(SPECIES.length());
2704         int[] b = fb.apply(SPECIES.length());
2705         int[] r = fr.apply(SPECIES.length());
2706 
2707         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2708             for (int i = 0; i < a.length; i += SPECIES.length()) {
2709                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2710                 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
2711             }
2712         }
2713 
2714         assertShiftArraysEquals(r, a, b, Int64VectorTests::ASHR_unary);
2715     }
2716 
2717     @Test(dataProvider = "intBinaryOpMaskProvider")
2718     static void ASHRInt64VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2719                                           IntFunction<boolean[]> fm) {
2720         int[] a = fa.apply(SPECIES.length());
2721         int[] b = fb.apply(SPECIES.length());
2722         int[] r = fr.apply(SPECIES.length());
2723         boolean[] mask = fm.apply(SPECIES.length());
2724         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2725 
2726         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2727             for (int i = 0; i < a.length; i += SPECIES.length()) {
2728                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2729                 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
2730             }
2731         }
2732 
2733         assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::ASHR_unary);
2734     }
2735 
2736     static int ROR(int a, int b) {
2737         return (int)(ROR_scalar(a,b));
2738     }
2739 
2740     @Test(dataProvider = "intBinaryOpProvider")
2741     static void RORInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2742         int[] a = fa.apply(SPECIES.length());
2743         int[] b = fb.apply(SPECIES.length());
2744         int[] r = fr.apply(SPECIES.length());
2745 
2746         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2747             for (int i = 0; i < a.length; i += SPECIES.length()) {
2748                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2749                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2750                 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
2751             }
2752         }
2753 
2754         assertArraysEquals(r, a, b, Int64VectorTests::ROR);
2755     }
2756 
2757     @Test(dataProvider = "intBinaryOpMaskProvider")
2758     static void RORInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2759                                           IntFunction<boolean[]> fm) {
2760         int[] a = fa.apply(SPECIES.length());
2761         int[] b = fb.apply(SPECIES.length());
2762         int[] r = fr.apply(SPECIES.length());
2763         boolean[] mask = fm.apply(SPECIES.length());
2764         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2765 
2766         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2767             for (int i = 0; i < a.length; i += SPECIES.length()) {
2768                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2769                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2770                 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
2771             }
2772         }
2773 
2774         assertArraysEquals(r, a, b, mask, Int64VectorTests::ROR);
2775     }
2776 
2777     static int ROL(int a, int b) {
2778         return (int)(ROL_scalar(a,b));
2779     }
2780 
2781     @Test(dataProvider = "intBinaryOpProvider")
2782     static void ROLInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2783         int[] a = fa.apply(SPECIES.length());
2784         int[] b = fb.apply(SPECIES.length());
2785         int[] r = fr.apply(SPECIES.length());
2786 
2787         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2788             for (int i = 0; i < a.length; i += SPECIES.length()) {
2789                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2790                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2791                 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
2792             }
2793         }
2794 
2795         assertArraysEquals(r, a, b, Int64VectorTests::ROL);
2796     }
2797 
2798     @Test(dataProvider = "intBinaryOpMaskProvider")
2799     static void ROLInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2800                                           IntFunction<boolean[]> fm) {
2801         int[] a = fa.apply(SPECIES.length());
2802         int[] b = fb.apply(SPECIES.length());
2803         int[] r = fr.apply(SPECIES.length());
2804         boolean[] mask = fm.apply(SPECIES.length());
2805         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2806 
2807         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2808             for (int i = 0; i < a.length; i += SPECIES.length()) {
2809                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2810                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2811                 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
2812             }
2813         }
2814 
2815         assertArraysEquals(r, a, b, mask, Int64VectorTests::ROL);
2816     }
2817 
2818     static int ROR_unary(int a, int b) {
2819         return (int)(ROR_scalar(a, b));
2820     }
2821 
2822     @Test(dataProvider = "intBinaryOpProvider")
2823     static void RORInt64VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2824         int[] a = fa.apply(SPECIES.length());
2825         int[] b = fb.apply(SPECIES.length());
2826         int[] r = fr.apply(SPECIES.length());
2827 
2828         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2829             for (int i = 0; i < a.length; i += SPECIES.length()) {
2830                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2831                 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
2832             }
2833         }
2834 
2835         assertShiftArraysEquals(r, a, b, Int64VectorTests::ROR_unary);
2836     }
2837 
2838     @Test(dataProvider = "intBinaryOpMaskProvider")
2839     static void RORInt64VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2840                                           IntFunction<boolean[]> fm) {
2841         int[] a = fa.apply(SPECIES.length());
2842         int[] b = fb.apply(SPECIES.length());
2843         int[] r = fr.apply(SPECIES.length());
2844         boolean[] mask = fm.apply(SPECIES.length());
2845         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2846 
2847         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2848             for (int i = 0; i < a.length; i += SPECIES.length()) {
2849                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2850                 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
2851             }
2852         }
2853 
2854         assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::ROR_unary);
2855     }
2856 
2857     static int ROL_unary(int a, int b) {
2858         return (int)(ROL_scalar(a, b));
2859     }
2860 
2861     @Test(dataProvider = "intBinaryOpProvider")
2862     static void ROLInt64VectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2863         int[] a = fa.apply(SPECIES.length());
2864         int[] b = fb.apply(SPECIES.length());
2865         int[] r = fr.apply(SPECIES.length());
2866 
2867         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2868             for (int i = 0; i < a.length; i += SPECIES.length()) {
2869                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2870                 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
2871             }
2872         }
2873 
2874         assertShiftArraysEquals(r, a, b, Int64VectorTests::ROL_unary);
2875     }
2876 
2877     @Test(dataProvider = "intBinaryOpMaskProvider")
2878     static void ROLInt64VectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2879                                           IntFunction<boolean[]> fm) {
2880         int[] a = fa.apply(SPECIES.length());
2881         int[] b = fb.apply(SPECIES.length());
2882         int[] r = fr.apply(SPECIES.length());
2883         boolean[] mask = fm.apply(SPECIES.length());
2884         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2885 
2886         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2887             for (int i = 0; i < a.length; i += SPECIES.length()) {
2888                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2889                 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
2890             }
2891         }
2892 
2893         assertShiftArraysEquals(r, a, b, mask, Int64VectorTests::ROL_unary);
2894     }
2895     static int LSHR_binary_const(int a) {
2896         return (int)((a >>> CONST_SHIFT));
2897     }
2898 
2899     @Test(dataProvider = "intUnaryOpProvider")
2900     static void LSHRInt64VectorTestsScalarShiftConst(IntFunction<int[]> fa) {
2901         int[] a = fa.apply(SPECIES.length());
2902         int[] r = fr.apply(SPECIES.length());
2903 
2904         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2905             for (int i = 0; i < a.length; i += SPECIES.length()) {
2906                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2907                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i);
2908             }
2909         }
2910 
2911         assertShiftConstEquals(r, a, Int64VectorTests::LSHR_binary_const);
2912     }
2913 
2914     @Test(dataProvider = "intUnaryOpMaskProvider")
2915     static void LSHRInt64VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
2916                                           IntFunction<boolean[]> fm) {
2917         int[] a = fa.apply(SPECIES.length());
2918         int[] r = fr.apply(SPECIES.length());
2919         boolean[] mask = fm.apply(SPECIES.length());
2920         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2921 
2922         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2923             for (int i = 0; i < a.length; i += SPECIES.length()) {
2924                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2925                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i);
2926             }
2927         }
2928 
2929         assertShiftConstEquals(r, a, mask, Int64VectorTests::LSHR_binary_const);
2930     }
2931 
2932     static int LSHL_binary_const(int a) {
2933         return (int)((a << CONST_SHIFT));
2934     }
2935 
2936     @Test(dataProvider = "intUnaryOpProvider")
2937     static void LSHLInt64VectorTestsScalarShiftConst(IntFunction<int[]> fa) {
2938         int[] a = fa.apply(SPECIES.length());
2939         int[] r = fr.apply(SPECIES.length());
2940 
2941         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2942             for (int i = 0; i < a.length; i += SPECIES.length()) {
2943                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2944                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i);
2945             }
2946         }
2947 
2948         assertShiftConstEquals(r, a, Int64VectorTests::LSHL_binary_const);
2949     }
2950 
2951     @Test(dataProvider = "intUnaryOpMaskProvider")
2952     static void LSHLInt64VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
2953                                           IntFunction<boolean[]> fm) {
2954         int[] a = fa.apply(SPECIES.length());
2955         int[] r = fr.apply(SPECIES.length());
2956         boolean[] mask = fm.apply(SPECIES.length());
2957         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2958 
2959         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2960             for (int i = 0; i < a.length; i += SPECIES.length()) {
2961                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2962                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i);
2963             }
2964         }
2965 
2966         assertShiftConstEquals(r, a, mask, Int64VectorTests::LSHL_binary_const);
2967     }
2968 
2969     static int ASHR_binary_const(int a) {
2970         return (int)((a >> CONST_SHIFT));
2971     }
2972 
2973     @Test(dataProvider = "intUnaryOpProvider")
2974     static void ASHRInt64VectorTestsScalarShiftConst(IntFunction<int[]> fa) {
2975         int[] a = fa.apply(SPECIES.length());
2976         int[] r = fr.apply(SPECIES.length());
2977 
2978         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2979             for (int i = 0; i < a.length; i += SPECIES.length()) {
2980                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2981                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i);
2982             }
2983         }
2984 
2985         assertShiftConstEquals(r, a, Int64VectorTests::ASHR_binary_const);
2986     }
2987 
2988     @Test(dataProvider = "intUnaryOpMaskProvider")
2989     static void ASHRInt64VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
2990                                           IntFunction<boolean[]> fm) {
2991         int[] a = fa.apply(SPECIES.length());
2992         int[] r = fr.apply(SPECIES.length());
2993         boolean[] mask = fm.apply(SPECIES.length());
2994         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2995 
2996         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2997             for (int i = 0; i < a.length; i += SPECIES.length()) {
2998                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2999                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i);
3000             }
3001         }
3002 
3003         assertShiftConstEquals(r, a, mask, Int64VectorTests::ASHR_binary_const);
3004     }
3005 
3006     static int ROR_binary_const(int a) {
3007         return (int)(ROR_scalar(a, CONST_SHIFT));
3008     }
3009 
3010     @Test(dataProvider = "intUnaryOpProvider")
3011     static void RORInt64VectorTestsScalarShiftConst(IntFunction<int[]> fa) {
3012         int[] a = fa.apply(SPECIES.length());
3013         int[] r = fr.apply(SPECIES.length());
3014 
3015         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3016             for (int i = 0; i < a.length; i += SPECIES.length()) {
3017                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3018                 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i);
3019             }
3020         }
3021 
3022         assertShiftConstEquals(r, a, Int64VectorTests::ROR_binary_const);
3023     }
3024 
3025     @Test(dataProvider = "intUnaryOpMaskProvider")
3026     static void RORInt64VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
3027                                           IntFunction<boolean[]> fm) {
3028         int[] a = fa.apply(SPECIES.length());
3029         int[] r = fr.apply(SPECIES.length());
3030         boolean[] mask = fm.apply(SPECIES.length());
3031         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3032 
3033         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3034             for (int i = 0; i < a.length; i += SPECIES.length()) {
3035                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3036                 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i);
3037             }
3038         }
3039 
3040         assertShiftConstEquals(r, a, mask, Int64VectorTests::ROR_binary_const);
3041     }
3042 
3043     static int ROL_binary_const(int a) {
3044         return (int)(ROL_scalar(a, CONST_SHIFT));
3045     }
3046 
3047     @Test(dataProvider = "intUnaryOpProvider")
3048     static void ROLInt64VectorTestsScalarShiftConst(IntFunction<int[]> fa) {
3049         int[] a = fa.apply(SPECIES.length());
3050         int[] r = fr.apply(SPECIES.length());
3051 
3052         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3053             for (int i = 0; i < a.length; i += SPECIES.length()) {
3054                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3055                 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i);
3056             }
3057         }
3058 
3059         assertShiftConstEquals(r, a, Int64VectorTests::ROL_binary_const);
3060     }
3061 
3062     @Test(dataProvider = "intUnaryOpMaskProvider")
3063     static void ROLInt64VectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
3064                                           IntFunction<boolean[]> fm) {
3065         int[] a = fa.apply(SPECIES.length());
3066         int[] r = fr.apply(SPECIES.length());
3067         boolean[] mask = fm.apply(SPECIES.length());
3068         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3069 
3070         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3071             for (int i = 0; i < a.length; i += SPECIES.length()) {
3072                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3073                 av.lanewise(VectorOperators.ROL, CONST_SHIFT, vmask).intoArray(r, i);
3074             }
3075         }
3076 
3077         assertShiftConstEquals(r, a, mask, Int64VectorTests::ROL_binary_const);
3078     }
3079 
3080 


3081     @Test(dataProvider = "intUnaryOpProvider")
3082     static void MINInt64VectorTestsWithMemOp(IntFunction<int[]> fa) {
3083         int[] a = fa.apply(SPECIES.length());
3084         int[] r = fr.apply(SPECIES.length());
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                 av.lanewise(VectorOperators.MIN, bcast_vec).intoArray(r, i);
3090             }
3091         }
3092 
3093         assertArraysEquals(r, a, (int)10, Int64VectorTests::MIN);
3094     }
3095 


3096     @Test(dataProvider = "intUnaryOpProvider")
3097     static void minInt64VectorTestsWithMemOp(IntFunction<int[]> fa) {
3098         int[] a = fa.apply(SPECIES.length());
3099         int[] r = fr.apply(SPECIES.length());
3100 
3101         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3102             for (int i = 0; i < a.length; i += SPECIES.length()) {
3103                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3104                 av.min(bcast_vec).intoArray(r, i);
3105             }
3106         }
3107 
3108         assertArraysEquals(r, a, (int)10, Int64VectorTests::min);
3109     }
3110 


3111     @Test(dataProvider = "intUnaryOpMaskProvider")
3112     static void MINInt64VectorTestsMaskedWithMemOp(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3113         int[] a = fa.apply(SPECIES.length());
3114         int[] r = fr.apply(SPECIES.length());
3115         boolean[] mask = fm.apply(SPECIES.length());
3116         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3117 
3118         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3119             for (int i = 0; i < a.length; i += SPECIES.length()) {
3120                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3121                 av.lanewise(VectorOperators.MIN, bcast_vec, vmask).intoArray(r, i);
3122             }
3123         }
3124 
3125         assertArraysEquals(r, a, (int)10, mask, Int64VectorTests::MIN);
3126     }
3127 


3128     @Test(dataProvider = "intUnaryOpProvider")
3129     static void MAXInt64VectorTestsWithMemOp(IntFunction<int[]> fa) {
3130         int[] a = fa.apply(SPECIES.length());
3131         int[] r = fr.apply(SPECIES.length());
3132 
3133         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3134             for (int i = 0; i < a.length; i += SPECIES.length()) {
3135                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3136                 av.lanewise(VectorOperators.MAX, bcast_vec).intoArray(r, i);
3137             }
3138         }
3139 
3140         assertArraysEquals(r, a, (int)10, Int64VectorTests::MAX);
3141     }
3142 


3143     @Test(dataProvider = "intUnaryOpProvider")
3144     static void maxInt64VectorTestsWithMemOp(IntFunction<int[]> fa) {
3145         int[] a = fa.apply(SPECIES.length());
3146         int[] r = fr.apply(SPECIES.length());
3147 
3148         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3149             for (int i = 0; i < a.length; i += SPECIES.length()) {
3150                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3151                 av.max(bcast_vec).intoArray(r, i);
3152             }
3153         }
3154 
3155         assertArraysEquals(r, a, (int)10, Int64VectorTests::max);
3156     }
3157 


3158     @Test(dataProvider = "intUnaryOpMaskProvider")
3159     static void MAXInt64VectorTestsMaskedWithMemOp(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3160         int[] a = fa.apply(SPECIES.length());
3161         int[] r = fr.apply(SPECIES.length());
3162         boolean[] mask = fm.apply(SPECIES.length());
3163         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3164 
3165         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3166             for (int i = 0; i < a.length; i += SPECIES.length()) {
3167                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3168                 av.lanewise(VectorOperators.MAX, bcast_vec, vmask).intoArray(r, i);
3169             }
3170         }
3171 
3172         assertArraysEquals(r, a, (int)10, mask, Int64VectorTests::MAX);
3173     }
3174 
3175     static int MIN(int a, int b) {
3176         return (int)(Math.min(a, b));
3177     }
3178 
3179     @Test(dataProvider = "intBinaryOpProvider")
3180     static void MINInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3181         int[] a = fa.apply(SPECIES.length());
3182         int[] b = fb.apply(SPECIES.length());
3183         int[] r = fr.apply(SPECIES.length());
3184 
3185         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3186             for (int i = 0; i < a.length; i += SPECIES.length()) {
3187                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3188                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3189                 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
3190             }
3191         }
3192 
3193         assertArraysEquals(r, a, b, Int64VectorTests::MIN);
3194     }
3195 
3196     static int min(int a, int b) {
3197         return (int)(Math.min(a, b));
3198     }
3199 
3200     @Test(dataProvider = "intBinaryOpProvider")
3201     static void minInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3202         int[] a = fa.apply(SPECIES.length());
3203         int[] b = fb.apply(SPECIES.length());
3204         int[] r = fr.apply(SPECIES.length());
3205 
3206         for (int i = 0; i < a.length; i += SPECIES.length()) {
3207             IntVector av = IntVector.fromArray(SPECIES, a, i);
3208             IntVector bv = IntVector.fromArray(SPECIES, b, i);
3209             av.min(bv).intoArray(r, i);
3210         }
3211 
3212         assertArraysEquals(r, a, b, Int64VectorTests::min);
3213     }
3214 
3215     static int MAX(int a, int b) {
3216         return (int)(Math.max(a, b));
3217     }
3218 
3219     @Test(dataProvider = "intBinaryOpProvider")
3220     static void MAXInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3221         int[] a = fa.apply(SPECIES.length());
3222         int[] b = fb.apply(SPECIES.length());
3223         int[] r = fr.apply(SPECIES.length());
3224 
3225         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3226             for (int i = 0; i < a.length; i += SPECIES.length()) {
3227                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3228                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3229                 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
3230             }
3231         }
3232 
3233         assertArraysEquals(r, a, b, Int64VectorTests::MAX);
3234     }
3235 
3236     static int max(int a, int b) {
3237         return (int)(Math.max(a, b));
3238     }
3239 
3240     @Test(dataProvider = "intBinaryOpProvider")
3241     static void maxInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3242         int[] a = fa.apply(SPECIES.length());
3243         int[] b = fb.apply(SPECIES.length());
3244         int[] r = fr.apply(SPECIES.length());
3245 
3246         for (int i = 0; i < a.length; i += SPECIES.length()) {
3247             IntVector av = IntVector.fromArray(SPECIES, a, i);
3248             IntVector bv = IntVector.fromArray(SPECIES, b, i);
3249             av.max(bv).intoArray(r, i);
3250         }
3251 
3252         assertArraysEquals(r, a, b, Int64VectorTests::max);
3253     }
3254 
3255     static int UMIN(int a, int b) {
3256         return (int)(VectorMath.minUnsigned(a, b));
3257     }
3258 
3259     @Test(dataProvider = "intBinaryOpProvider")
3260     static void UMINInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3261         int[] a = fa.apply(SPECIES.length());
3262         int[] b = fb.apply(SPECIES.length());
3263         int[] r = fr.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                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3269                 av.lanewise(VectorOperators.UMIN, bv).intoArray(r, i);
3270             }
3271         }
3272 
3273         assertArraysEquals(r, a, b, Int64VectorTests::UMIN);
3274     }
3275 
3276     @Test(dataProvider = "intBinaryOpMaskProvider")
3277     static void UMINInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3278                                           IntFunction<boolean[]> fm) {
3279         int[] a = fa.apply(SPECIES.length());
3280         int[] b = fb.apply(SPECIES.length());
3281         int[] r = fr.apply(SPECIES.length());
3282         boolean[] mask = fm.apply(SPECIES.length());
3283         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3284 
3285         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3286             for (int i = 0; i < a.length; i += SPECIES.length()) {
3287                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3288                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3289                 av.lanewise(VectorOperators.UMIN, bv, vmask).intoArray(r, i);
3290             }
3291         }
3292 
3293         assertArraysEquals(r, a, b, mask, Int64VectorTests::UMIN);
3294     }
3295 
3296     static int UMAX(int a, int b) {
3297         return (int)(VectorMath.maxUnsigned(a, b));
3298     }
3299 
3300     @Test(dataProvider = "intBinaryOpProvider")
3301     static void UMAXInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3302         int[] a = fa.apply(SPECIES.length());
3303         int[] b = fb.apply(SPECIES.length());
3304         int[] r = fr.apply(SPECIES.length());
3305 
3306         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3307             for (int i = 0; i < a.length; i += SPECIES.length()) {
3308                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3309                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3310                 av.lanewise(VectorOperators.UMAX, bv).intoArray(r, i);
3311             }
3312         }
3313 
3314         assertArraysEquals(r, a, b, Int64VectorTests::UMAX);
3315     }
3316 
3317     @Test(dataProvider = "intBinaryOpMaskProvider")
3318     static void UMAXInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3319                                           IntFunction<boolean[]> fm) {
3320         int[] a = fa.apply(SPECIES.length());
3321         int[] b = fb.apply(SPECIES.length());
3322         int[] r = fr.apply(SPECIES.length());
3323         boolean[] mask = fm.apply(SPECIES.length());
3324         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3325 
3326         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3327             for (int i = 0; i < a.length; i += SPECIES.length()) {
3328                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3329                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3330                 av.lanewise(VectorOperators.UMAX, bv, vmask).intoArray(r, i);
3331             }
3332         }
3333 
3334         assertArraysEquals(r, a, b, mask, Int64VectorTests::UMAX);
3335     }
3336 
3337     static int SADD(int a, int b) {
3338         return (int)(VectorMath.addSaturating(a, b));
3339     }
3340 
3341     @Test(dataProvider = "intSaturatingBinaryOpProvider")
3342     static void SADDInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3343         int[] a = fa.apply(SPECIES.length());
3344         int[] b = fb.apply(SPECIES.length());
3345         int[] r = fr.apply(SPECIES.length());
3346 
3347         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3348             for (int i = 0; i < a.length; i += SPECIES.length()) {
3349                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3350                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3351                 av.lanewise(VectorOperators.SADD, bv).intoArray(r, i);
3352             }
3353         }
3354 
3355         assertArraysEquals(r, a, b, Int64VectorTests::SADD);
3356     }
3357 
3358     @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3359     static void SADDInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3360                                           IntFunction<boolean[]> fm) {
3361         int[] a = fa.apply(SPECIES.length());
3362         int[] b = fb.apply(SPECIES.length());
3363         int[] r = fr.apply(SPECIES.length());
3364         boolean[] mask = fm.apply(SPECIES.length());
3365         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3366 
3367         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3368             for (int i = 0; i < a.length; i += SPECIES.length()) {
3369                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3370                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3371                 av.lanewise(VectorOperators.SADD, bv, vmask).intoArray(r, i);
3372             }
3373         }
3374 
3375         assertArraysEquals(r, a, b, mask, Int64VectorTests::SADD);
3376     }
3377 
3378     static int SSUB(int a, int b) {
3379         return (int)(VectorMath.subSaturating(a, b));
3380     }
3381 
3382     @Test(dataProvider = "intSaturatingBinaryOpProvider")
3383     static void SSUBInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3384         int[] a = fa.apply(SPECIES.length());
3385         int[] b = fb.apply(SPECIES.length());
3386         int[] r = fr.apply(SPECIES.length());
3387 
3388         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3389             for (int i = 0; i < a.length; i += SPECIES.length()) {
3390                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3391                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3392                 av.lanewise(VectorOperators.SSUB, bv).intoArray(r, i);
3393             }
3394         }
3395 
3396         assertArraysEquals(r, a, b, Int64VectorTests::SSUB);
3397     }
3398 
3399     @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3400     static void SSUBInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3401                                           IntFunction<boolean[]> fm) {
3402         int[] a = fa.apply(SPECIES.length());
3403         int[] b = fb.apply(SPECIES.length());
3404         int[] r = fr.apply(SPECIES.length());
3405         boolean[] mask = fm.apply(SPECIES.length());
3406         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3407 
3408         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3409             for (int i = 0; i < a.length; i += SPECIES.length()) {
3410                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3411                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3412                 av.lanewise(VectorOperators.SSUB, bv, vmask).intoArray(r, i);
3413             }
3414         }
3415 
3416         assertArraysEquals(r, a, b, mask, Int64VectorTests::SSUB);
3417     }
3418 
3419     static int SUADD(int a, int b) {
3420         return (int)(VectorMath.addSaturatingUnsigned(a, b));
3421     }
3422 
3423     @Test(dataProvider = "intSaturatingBinaryOpProvider")
3424     static void SUADDInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3425         int[] a = fa.apply(SPECIES.length());
3426         int[] b = fb.apply(SPECIES.length());
3427         int[] r = fr.apply(SPECIES.length());
3428 
3429         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3430             for (int i = 0; i < a.length; i += SPECIES.length()) {
3431                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3432                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3433                 av.lanewise(VectorOperators.SUADD, bv).intoArray(r, i);
3434             }
3435         }
3436 
3437         assertArraysEquals(r, a, b, Int64VectorTests::SUADD);
3438     }
3439 
3440     @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3441     static void SUADDInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3442                                           IntFunction<boolean[]> fm) {
3443         int[] a = fa.apply(SPECIES.length());
3444         int[] b = fb.apply(SPECIES.length());
3445         int[] r = fr.apply(SPECIES.length());
3446         boolean[] mask = fm.apply(SPECIES.length());
3447         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3448 
3449         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3450             for (int i = 0; i < a.length; i += SPECIES.length()) {
3451                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3452                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3453                 av.lanewise(VectorOperators.SUADD, bv, vmask).intoArray(r, i);
3454             }
3455         }
3456 
3457         assertArraysEquals(r, a, b, mask, Int64VectorTests::SUADD);
3458     }
3459 
3460     static int SUSUB(int a, int b) {
3461         return (int)(VectorMath.subSaturatingUnsigned(a, b));
3462     }
3463 
3464     @Test(dataProvider = "intSaturatingBinaryOpProvider")
3465     static void SUSUBInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3466         int[] a = fa.apply(SPECIES.length());
3467         int[] b = fb.apply(SPECIES.length());
3468         int[] r = fr.apply(SPECIES.length());
3469 
3470         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3471             for (int i = 0; i < a.length; i += SPECIES.length()) {
3472                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3473                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3474                 av.lanewise(VectorOperators.SUSUB, bv).intoArray(r, i);
3475             }
3476         }
3477 
3478         assertArraysEquals(r, a, b, Int64VectorTests::SUSUB);
3479     }
3480 
3481     @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3482     static void SUSUBInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3483                                           IntFunction<boolean[]> fm) {
3484         int[] a = fa.apply(SPECIES.length());
3485         int[] b = fb.apply(SPECIES.length());
3486         int[] r = fr.apply(SPECIES.length());
3487         boolean[] mask = fm.apply(SPECIES.length());
3488         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3489 
3490         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3491             for (int i = 0; i < a.length; i += SPECIES.length()) {
3492                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3493                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3494                 av.lanewise(VectorOperators.SUSUB, bv, vmask).intoArray(r, i);
3495             }
3496         }
3497 
3498         assertArraysEquals(r, a, b, mask, Int64VectorTests::SUSUB);
3499     }
3500 
3501     @Test(dataProvider = "intBinaryOpProvider")
3502     static void MINInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3503         int[] a = fa.apply(SPECIES.length());
3504         int[] b = fb.apply(SPECIES.length());
3505         int[] r = fr.apply(SPECIES.length());
3506 
3507         for (int i = 0; i < a.length; i += SPECIES.length()) {
3508             IntVector av = IntVector.fromArray(SPECIES, a, i);
3509             av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
3510         }
3511 
3512         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::MIN);
3513     }
3514 
3515     @Test(dataProvider = "intBinaryOpProvider")
3516     static void minInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3517         int[] a = fa.apply(SPECIES.length());
3518         int[] b = fb.apply(SPECIES.length());
3519         int[] r = fr.apply(SPECIES.length());
3520 
3521         for (int i = 0; i < a.length; i += SPECIES.length()) {
3522             IntVector av = IntVector.fromArray(SPECIES, a, i);
3523             av.min(b[i]).intoArray(r, i);
3524         }
3525 
3526         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::min);
3527     }
3528 
3529     @Test(dataProvider = "intBinaryOpProvider")
3530     static void MAXInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3531         int[] a = fa.apply(SPECIES.length());
3532         int[] b = fb.apply(SPECIES.length());
3533         int[] r = fr.apply(SPECIES.length());
3534 
3535         for (int i = 0; i < a.length; i += SPECIES.length()) {
3536             IntVector av = IntVector.fromArray(SPECIES, a, i);
3537             av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
3538         }
3539 
3540         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::MAX);
3541     }
3542 
3543     @Test(dataProvider = "intBinaryOpProvider")
3544     static void maxInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3545         int[] a = fa.apply(SPECIES.length());
3546         int[] b = fb.apply(SPECIES.length());
3547         int[] r = fr.apply(SPECIES.length());
3548 
3549         for (int i = 0; i < a.length; i += SPECIES.length()) {
3550             IntVector av = IntVector.fromArray(SPECIES, a, i);
3551             av.max(b[i]).intoArray(r, i);
3552         }
3553 
3554         assertBroadcastArraysEquals(r, a, b, Int64VectorTests::max);
3555     }
3556     @Test(dataProvider = "intSaturatingBinaryOpAssocProvider")
3557     static void SUADDAssocInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
3558         int[] a = fa.apply(SPECIES.length());
3559         int[] b = fb.apply(SPECIES.length());
3560         int[] c = fc.apply(SPECIES.length());
3561         int[] rl = fr.apply(SPECIES.length());
3562         int[] rr = fr.apply(SPECIES.length());
3563 
3564         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3565             for (int i = 0; i < a.length; i += SPECIES.length()) {
3566                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3567                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3568                 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3569                 av.lanewise(VectorOperators.SUADD, bv).lanewise(VectorOperators.SUADD, cv).intoArray(rl, i);
3570                 av.lanewise(VectorOperators.SUADD, bv.lanewise(VectorOperators.SUADD, cv)).intoArray(rr, i);
3571             }
3572         }
3573 
3574         assertArraysEqualsAssociative(rl, rr, a, b, c, Int64VectorTests::SUADD);
3575     }
3576 
3577     @Test(dataProvider = "intSaturatingBinaryOpAssocMaskProvider")
3578     static void SUADDAssocInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3579                                                      IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
3580         int[] a = fa.apply(SPECIES.length());
3581         int[] b = fb.apply(SPECIES.length());
3582         int[] c = fc.apply(SPECIES.length());
3583         boolean[] mask = fm.apply(SPECIES.length());
3584         int[] rl = fr.apply(SPECIES.length());
3585         int[] rr = fr.apply(SPECIES.length());
3586 
3587         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3588 
3589         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3590             for (int i = 0; i < a.length; i += SPECIES.length()) {
3591                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3592                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3593                 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3594                 av.lanewise(VectorOperators.SUADD, bv, vmask).lanewise(VectorOperators.SUADD, cv, vmask).intoArray(rl, i);
3595                 av.lanewise(VectorOperators.SUADD, bv.lanewise(VectorOperators.SUADD, cv, vmask), vmask).intoArray(rr, i);
3596             }
3597         }
3598 
3599         assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Int64VectorTests::SUADD);
3600     }
3601 
3602     static int ANDReduce(int[] a, int idx) {
3603         int res = -1;
3604         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3605             res &= a[i];
3606         }
3607 
3608         return res;
3609     }
3610 
3611     static int ANDReduceAll(int[] a) {
3612         int res = -1;
3613         for (int i = 0; i < a.length; i += SPECIES.length()) {
3614             res &= ANDReduce(a, i);
3615         }
3616 
3617         return res;
3618     }
3619 
3620     @Test(dataProvider = "intUnaryOpProvider")
3621     static void ANDReduceInt64VectorTests(IntFunction<int[]> fa) {
3622         int[] a = fa.apply(SPECIES.length());
3623         int[] r = fr.apply(SPECIES.length());
3624         int ra = -1;
3625 
3626         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3627             for (int i = 0; i < a.length; i += SPECIES.length()) {
3628                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3629                 r[i] = av.reduceLanes(VectorOperators.AND);
3630             }
3631         }
3632 
3633         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3634             ra = -1;
3635             for (int i = 0; i < a.length; i += SPECIES.length()) {
3636                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3637                 ra &= av.reduceLanes(VectorOperators.AND);
3638             }
3639         }
3640 
3641         assertReductionArraysEquals(r, ra, a,
3642                 Int64VectorTests::ANDReduce, Int64VectorTests::ANDReduceAll);
3643     }
3644 
3645     static int ANDReduceMasked(int[] a, int idx, boolean[] mask) {
3646         int res = -1;
3647         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3648             if (mask[i % SPECIES.length()])
3649                 res &= a[i];
3650         }
3651 
3652         return res;
3653     }
3654 
3655     static int ANDReduceAllMasked(int[] a, boolean[] mask) {
3656         int res = -1;
3657         for (int i = 0; i < a.length; i += SPECIES.length()) {
3658             res &= ANDReduceMasked(a, i, mask);
3659         }
3660 
3661         return res;
3662     }
3663 
3664     @Test(dataProvider = "intUnaryOpMaskProvider")
3665     static void ANDReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3666         int[] a = fa.apply(SPECIES.length());
3667         int[] r = fr.apply(SPECIES.length());
3668         boolean[] mask = fm.apply(SPECIES.length());
3669         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3670         int ra = -1;
3671 
3672         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3673             for (int i = 0; i < a.length; i += SPECIES.length()) {
3674                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3675                 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
3676             }
3677         }
3678 
3679         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3680             ra = -1;
3681             for (int i = 0; i < a.length; i += SPECIES.length()) {
3682                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3683                 ra &= av.reduceLanes(VectorOperators.AND, vmask);
3684             }
3685         }
3686 
3687         assertReductionArraysEqualsMasked(r, ra, a, mask,
3688                 Int64VectorTests::ANDReduceMasked, Int64VectorTests::ANDReduceAllMasked);
3689     }
3690 
3691     static int ORReduce(int[] a, int idx) {
3692         int res = 0;
3693         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3694             res |= a[i];
3695         }
3696 
3697         return res;
3698     }
3699 
3700     static int ORReduceAll(int[] a) {
3701         int res = 0;
3702         for (int i = 0; i < a.length; i += SPECIES.length()) {
3703             res |= ORReduce(a, i);
3704         }
3705 
3706         return res;
3707     }
3708 
3709     @Test(dataProvider = "intUnaryOpProvider")
3710     static void ORReduceInt64VectorTests(IntFunction<int[]> fa) {
3711         int[] a = fa.apply(SPECIES.length());
3712         int[] r = fr.apply(SPECIES.length());
3713         int ra = 0;
3714 
3715         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3716             for (int i = 0; i < a.length; i += SPECIES.length()) {
3717                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3718                 r[i] = av.reduceLanes(VectorOperators.OR);
3719             }
3720         }
3721 
3722         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3723             ra = 0;
3724             for (int i = 0; i < a.length; i += SPECIES.length()) {
3725                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3726                 ra |= av.reduceLanes(VectorOperators.OR);
3727             }
3728         }
3729 
3730         assertReductionArraysEquals(r, ra, a,
3731                 Int64VectorTests::ORReduce, Int64VectorTests::ORReduceAll);
3732     }
3733 
3734     static int ORReduceMasked(int[] a, int idx, boolean[] mask) {
3735         int res = 0;
3736         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3737             if (mask[i % SPECIES.length()])
3738                 res |= a[i];
3739         }
3740 
3741         return res;
3742     }
3743 
3744     static int ORReduceAllMasked(int[] a, boolean[] mask) {
3745         int res = 0;
3746         for (int i = 0; i < a.length; i += SPECIES.length()) {
3747             res |= ORReduceMasked(a, i, mask);
3748         }
3749 
3750         return res;
3751     }
3752 
3753     @Test(dataProvider = "intUnaryOpMaskProvider")
3754     static void ORReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3755         int[] a = fa.apply(SPECIES.length());
3756         int[] r = fr.apply(SPECIES.length());
3757         boolean[] mask = fm.apply(SPECIES.length());
3758         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3759         int ra = 0;
3760 
3761         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3762             for (int i = 0; i < a.length; i += SPECIES.length()) {
3763                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3764                 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
3765             }
3766         }
3767 
3768         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3769             ra = 0;
3770             for (int i = 0; i < a.length; i += SPECIES.length()) {
3771                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3772                 ra |= av.reduceLanes(VectorOperators.OR, vmask);
3773             }
3774         }
3775 
3776         assertReductionArraysEqualsMasked(r, ra, a, mask,
3777                 Int64VectorTests::ORReduceMasked, Int64VectorTests::ORReduceAllMasked);
3778     }
3779 
3780     static int XORReduce(int[] a, int idx) {
3781         int res = 0;
3782         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3783             res ^= a[i];
3784         }
3785 
3786         return res;
3787     }
3788 
3789     static int XORReduceAll(int[] a) {
3790         int res = 0;
3791         for (int i = 0; i < a.length; i += SPECIES.length()) {
3792             res ^= XORReduce(a, i);
3793         }
3794 
3795         return res;
3796     }
3797 
3798     @Test(dataProvider = "intUnaryOpProvider")
3799     static void XORReduceInt64VectorTests(IntFunction<int[]> fa) {
3800         int[] a = fa.apply(SPECIES.length());
3801         int[] r = fr.apply(SPECIES.length());
3802         int ra = 0;
3803 
3804         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3805             for (int i = 0; i < a.length; i += SPECIES.length()) {
3806                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3807                 r[i] = av.reduceLanes(VectorOperators.XOR);
3808             }
3809         }
3810 
3811         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3812             ra = 0;
3813             for (int i = 0; i < a.length; i += SPECIES.length()) {
3814                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3815                 ra ^= av.reduceLanes(VectorOperators.XOR);
3816             }
3817         }
3818 
3819         assertReductionArraysEquals(r, ra, a,
3820                 Int64VectorTests::XORReduce, Int64VectorTests::XORReduceAll);
3821     }
3822 
3823     static int XORReduceMasked(int[] a, int idx, boolean[] mask) {
3824         int res = 0;
3825         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3826             if (mask[i % SPECIES.length()])
3827                 res ^= a[i];
3828         }
3829 
3830         return res;
3831     }
3832 
3833     static int XORReduceAllMasked(int[] a, boolean[] mask) {
3834         int res = 0;
3835         for (int i = 0; i < a.length; i += SPECIES.length()) {
3836             res ^= XORReduceMasked(a, i, mask);
3837         }
3838 
3839         return res;
3840     }
3841 
3842     @Test(dataProvider = "intUnaryOpMaskProvider")
3843     static void XORReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3844         int[] a = fa.apply(SPECIES.length());
3845         int[] r = fr.apply(SPECIES.length());
3846         boolean[] mask = fm.apply(SPECIES.length());
3847         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3848         int ra = 0;
3849 
3850         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3851             for (int i = 0; i < a.length; i += SPECIES.length()) {
3852                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3853                 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
3854             }
3855         }
3856 
3857         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3858             ra = 0;
3859             for (int i = 0; i < a.length; i += SPECIES.length()) {
3860                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3861                 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
3862             }
3863         }
3864 
3865         assertReductionArraysEqualsMasked(r, ra, a, mask,
3866                 Int64VectorTests::XORReduceMasked, Int64VectorTests::XORReduceAllMasked);
3867     }
3868 
3869     static int ADDReduce(int[] a, int idx) {
3870         int res = 0;
3871         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3872             res += a[i];
3873         }
3874 
3875         return res;
3876     }
3877 
3878     static int ADDReduceAll(int[] a) {
3879         int res = 0;
3880         for (int i = 0; i < a.length; i += SPECIES.length()) {
3881             res += ADDReduce(a, i);
3882         }
3883 
3884         return res;
3885     }
3886 
3887     @Test(dataProvider = "intUnaryOpProvider")
3888     static void ADDReduceInt64VectorTests(IntFunction<int[]> fa) {
3889         int[] a = fa.apply(SPECIES.length());
3890         int[] r = fr.apply(SPECIES.length());
3891         int ra = 0;
3892 
3893         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3894             for (int i = 0; i < a.length; i += SPECIES.length()) {
3895                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3896                 r[i] = av.reduceLanes(VectorOperators.ADD);
3897             }
3898         }
3899 
3900         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3901             ra = 0;
3902             for (int i = 0; i < a.length; i += SPECIES.length()) {
3903                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3904                 ra += av.reduceLanes(VectorOperators.ADD);
3905             }
3906         }
3907 
3908         assertReductionArraysEquals(r, ra, a,
3909                 Int64VectorTests::ADDReduce, Int64VectorTests::ADDReduceAll);
3910     }
3911 
3912     static int ADDReduceMasked(int[] a, int idx, boolean[] mask) {
3913         int res = 0;
3914         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3915             if (mask[i % SPECIES.length()])
3916                 res += a[i];
3917         }
3918 
3919         return res;
3920     }
3921 
3922     static int ADDReduceAllMasked(int[] a, boolean[] mask) {
3923         int res = 0;
3924         for (int i = 0; i < a.length; i += SPECIES.length()) {
3925             res += ADDReduceMasked(a, i, mask);
3926         }
3927 
3928         return res;
3929     }
3930 
3931     @Test(dataProvider = "intUnaryOpMaskProvider")
3932     static void ADDReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3933         int[] a = fa.apply(SPECIES.length());
3934         int[] r = fr.apply(SPECIES.length());
3935         boolean[] mask = fm.apply(SPECIES.length());
3936         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3937         int ra = 0;
3938 
3939         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3940             for (int i = 0; i < a.length; i += SPECIES.length()) {
3941                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3942                 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
3943             }
3944         }
3945 
3946         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3947             ra = 0;
3948             for (int i = 0; i < a.length; i += SPECIES.length()) {
3949                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3950                 ra += av.reduceLanes(VectorOperators.ADD, vmask);
3951             }
3952         }
3953 
3954         assertReductionArraysEqualsMasked(r, ra, a, mask,
3955                 Int64VectorTests::ADDReduceMasked, Int64VectorTests::ADDReduceAllMasked);
3956     }
3957 
3958     static int MULReduce(int[] a, int idx) {
3959         int res = 1;
3960         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3961             res *= a[i];
3962         }
3963 
3964         return res;
3965     }
3966 
3967     static int MULReduceAll(int[] a) {
3968         int res = 1;
3969         for (int i = 0; i < a.length; i += SPECIES.length()) {
3970             res *= MULReduce(a, i);
3971         }
3972 
3973         return res;
3974     }
3975 
3976     @Test(dataProvider = "intUnaryOpProvider")
3977     static void MULReduceInt64VectorTests(IntFunction<int[]> fa) {
3978         int[] a = fa.apply(SPECIES.length());
3979         int[] r = fr.apply(SPECIES.length());
3980         int ra = 1;
3981 
3982         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3983             for (int i = 0; i < a.length; i += SPECIES.length()) {
3984                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3985                 r[i] = av.reduceLanes(VectorOperators.MUL);
3986             }
3987         }
3988 
3989         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3990             ra = 1;
3991             for (int i = 0; i < a.length; i += SPECIES.length()) {
3992                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3993                 ra *= av.reduceLanes(VectorOperators.MUL);
3994             }
3995         }
3996 
3997         assertReductionArraysEquals(r, ra, a,
3998                 Int64VectorTests::MULReduce, Int64VectorTests::MULReduceAll);
3999     }
4000 
4001     static int MULReduceMasked(int[] a, int idx, boolean[] mask) {
4002         int res = 1;
4003         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4004             if (mask[i % SPECIES.length()])
4005                 res *= a[i];
4006         }
4007 
4008         return res;
4009     }
4010 
4011     static int MULReduceAllMasked(int[] a, boolean[] mask) {
4012         int res = 1;
4013         for (int i = 0; i < a.length; i += SPECIES.length()) {
4014             res *= MULReduceMasked(a, i, mask);
4015         }
4016 
4017         return res;
4018     }
4019 
4020     @Test(dataProvider = "intUnaryOpMaskProvider")
4021     static void MULReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4022         int[] a = fa.apply(SPECIES.length());
4023         int[] r = fr.apply(SPECIES.length());
4024         boolean[] mask = fm.apply(SPECIES.length());
4025         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4026         int ra = 1;
4027 
4028         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4029             for (int i = 0; i < a.length; i += SPECIES.length()) {
4030                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4031                 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
4032             }
4033         }
4034 
4035         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4036             ra = 1;
4037             for (int i = 0; i < a.length; i += SPECIES.length()) {
4038                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4039                 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
4040             }
4041         }
4042 
4043         assertReductionArraysEqualsMasked(r, ra, a, mask,
4044                 Int64VectorTests::MULReduceMasked, Int64VectorTests::MULReduceAllMasked);
4045     }
4046 
4047     static int MINReduce(int[] a, int idx) {
4048         int res = Integer.MAX_VALUE;
4049         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4050             res = (int) Math.min(res, a[i]);
4051         }
4052 
4053         return res;
4054     }
4055 
4056     static int MINReduceAll(int[] a) {
4057         int res = Integer.MAX_VALUE;
4058         for (int i = 0; i < a.length; i += SPECIES.length()) {
4059             res = (int) Math.min(res, MINReduce(a, i));
4060         }
4061 
4062         return res;
4063     }
4064 
4065     @Test(dataProvider = "intUnaryOpProvider")
4066     static void MINReduceInt64VectorTests(IntFunction<int[]> fa) {
4067         int[] a = fa.apply(SPECIES.length());
4068         int[] r = fr.apply(SPECIES.length());
4069         int ra = Integer.MAX_VALUE;
4070 
4071         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4072             for (int i = 0; i < a.length; i += SPECIES.length()) {
4073                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4074                 r[i] = av.reduceLanes(VectorOperators.MIN);
4075             }
4076         }
4077 
4078         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4079             ra = Integer.MAX_VALUE;
4080             for (int i = 0; i < a.length; i += SPECIES.length()) {
4081                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4082                 ra = (int) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
4083             }
4084         }
4085 
4086         assertReductionArraysEquals(r, ra, a,
4087                 Int64VectorTests::MINReduce, Int64VectorTests::MINReduceAll);
4088     }
4089 
4090     static int MINReduceMasked(int[] a, int idx, boolean[] mask) {
4091         int res = Integer.MAX_VALUE;
4092         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4093             if (mask[i % SPECIES.length()])
4094                 res = (int) Math.min(res, a[i]);
4095         }
4096 
4097         return res;
4098     }
4099 
4100     static int MINReduceAllMasked(int[] a, boolean[] mask) {
4101         int res = Integer.MAX_VALUE;
4102         for (int i = 0; i < a.length; i += SPECIES.length()) {
4103             res = (int) Math.min(res, MINReduceMasked(a, i, mask));
4104         }
4105 
4106         return res;
4107     }
4108 
4109     @Test(dataProvider = "intUnaryOpMaskProvider")
4110     static void MINReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4111         int[] a = fa.apply(SPECIES.length());
4112         int[] r = fr.apply(SPECIES.length());
4113         boolean[] mask = fm.apply(SPECIES.length());
4114         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4115         int ra = Integer.MAX_VALUE;
4116 
4117         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4118             for (int i = 0; i < a.length; i += SPECIES.length()) {
4119                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4120                 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
4121             }
4122         }
4123 
4124         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4125             ra = Integer.MAX_VALUE;
4126             for (int i = 0; i < a.length; i += SPECIES.length()) {
4127                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4128                 ra = (int) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
4129             }
4130         }
4131 
4132         assertReductionArraysEqualsMasked(r, ra, a, mask,
4133                 Int64VectorTests::MINReduceMasked, Int64VectorTests::MINReduceAllMasked);
4134     }
4135 
4136     static int MAXReduce(int[] a, int idx) {
4137         int res = Integer.MIN_VALUE;
4138         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4139             res = (int) Math.max(res, a[i]);
4140         }
4141 
4142         return res;
4143     }
4144 
4145     static int MAXReduceAll(int[] a) {
4146         int res = Integer.MIN_VALUE;
4147         for (int i = 0; i < a.length; i += SPECIES.length()) {
4148             res = (int) Math.max(res, MAXReduce(a, i));
4149         }
4150 
4151         return res;
4152     }
4153 
4154     @Test(dataProvider = "intUnaryOpProvider")
4155     static void MAXReduceInt64VectorTests(IntFunction<int[]> fa) {
4156         int[] a = fa.apply(SPECIES.length());
4157         int[] r = fr.apply(SPECIES.length());
4158         int ra = Integer.MIN_VALUE;
4159 
4160         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4161             for (int i = 0; i < a.length; i += SPECIES.length()) {
4162                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4163                 r[i] = av.reduceLanes(VectorOperators.MAX);
4164             }
4165         }
4166 
4167         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4168             ra = Integer.MIN_VALUE;
4169             for (int i = 0; i < a.length; i += SPECIES.length()) {
4170                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4171                 ra = (int) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
4172             }
4173         }
4174 
4175         assertReductionArraysEquals(r, ra, a,
4176                 Int64VectorTests::MAXReduce, Int64VectorTests::MAXReduceAll);
4177     }
4178 
4179     static int MAXReduceMasked(int[] a, int idx, boolean[] mask) {
4180         int res = Integer.MIN_VALUE;
4181         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4182             if (mask[i % SPECIES.length()])
4183                 res = (int) Math.max(res, a[i]);
4184         }
4185 
4186         return res;
4187     }
4188 
4189     static int MAXReduceAllMasked(int[] a, boolean[] mask) {
4190         int res = Integer.MIN_VALUE;
4191         for (int i = 0; i < a.length; i += SPECIES.length()) {
4192             res = (int) Math.max(res, MAXReduceMasked(a, i, mask));
4193         }
4194 
4195         return res;
4196     }
4197 
4198     @Test(dataProvider = "intUnaryOpMaskProvider")
4199     static void MAXReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4200         int[] a = fa.apply(SPECIES.length());
4201         int[] r = fr.apply(SPECIES.length());
4202         boolean[] mask = fm.apply(SPECIES.length());
4203         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4204         int ra = Integer.MIN_VALUE;
4205 
4206         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4207             for (int i = 0; i < a.length; i += SPECIES.length()) {
4208                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4209                 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
4210             }
4211         }
4212 
4213         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4214             ra = Integer.MIN_VALUE;
4215             for (int i = 0; i < a.length; i += SPECIES.length()) {
4216                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4217                 ra = (int) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
4218             }
4219         }
4220 
4221         assertReductionArraysEqualsMasked(r, ra, a, mask,
4222                 Int64VectorTests::MAXReduceMasked, Int64VectorTests::MAXReduceAllMasked);
4223     }
4224 
4225     static int UMINReduce(int[] a, int idx) {
4226         int res = Integer.MAX_VALUE;
4227         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4228             res = (int) VectorMath.minUnsigned(res, a[i]);
4229         }
4230 
4231         return res;
4232     }
4233 
4234     static int UMINReduceAll(int[] a) {
4235         int res = Integer.MAX_VALUE;
4236         for (int i = 0; i < a.length; i += SPECIES.length()) {
4237             res = (int) VectorMath.minUnsigned(res, UMINReduce(a, i));
4238         }
4239 
4240         return res;
4241     }
4242 
4243     @Test(dataProvider = "intUnaryOpProvider")
4244     static void UMINReduceInt64VectorTests(IntFunction<int[]> fa) {
4245         int[] a = fa.apply(SPECIES.length());
4246         int[] r = fr.apply(SPECIES.length());
4247         int ra = Integer.MAX_VALUE;
4248 
4249         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4250             for (int i = 0; i < a.length; i += SPECIES.length()) {
4251                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4252                 r[i] = av.reduceLanes(VectorOperators.UMIN);
4253             }
4254         }
4255 
4256         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4257             ra = Integer.MAX_VALUE;
4258             for (int i = 0; i < a.length; i += SPECIES.length()) {
4259                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4260                 ra = (int) VectorMath.minUnsigned(ra, av.reduceLanes(VectorOperators.UMIN));
4261             }
4262         }
4263 
4264         assertReductionArraysEquals(r, ra, a,
4265                 Int64VectorTests::UMINReduce, Int64VectorTests::UMINReduceAll);
4266     }
4267 
4268     static int UMINReduceMasked(int[] a, int idx, boolean[] mask) {
4269         int res = Integer.MAX_VALUE;
4270         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4271             if (mask[i % SPECIES.length()])
4272                 res = (int) VectorMath.minUnsigned(res, a[i]);
4273         }
4274 
4275         return res;
4276     }
4277 
4278     static int UMINReduceAllMasked(int[] a, boolean[] mask) {
4279         int res = Integer.MAX_VALUE;
4280         for (int i = 0; i < a.length; i += SPECIES.length()) {
4281             res = (int) VectorMath.minUnsigned(res, UMINReduceMasked(a, i, mask));
4282         }
4283 
4284         return res;
4285     }
4286 
4287     @Test(dataProvider = "intUnaryOpMaskProvider")
4288     static void UMINReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4289         int[] a = fa.apply(SPECIES.length());
4290         int[] r = fr.apply(SPECIES.length());
4291         boolean[] mask = fm.apply(SPECIES.length());
4292         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4293         int ra = Integer.MAX_VALUE;
4294 
4295         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4296             for (int i = 0; i < a.length; i += SPECIES.length()) {
4297                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4298                 r[i] = av.reduceLanes(VectorOperators.UMIN, vmask);
4299             }
4300         }
4301 
4302         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4303             ra = Integer.MAX_VALUE;
4304             for (int i = 0; i < a.length; i += SPECIES.length()) {
4305                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4306                 ra = (int) VectorMath.minUnsigned(ra, av.reduceLanes(VectorOperators.UMIN, vmask));
4307             }
4308         }
4309 
4310         assertReductionArraysEqualsMasked(r, ra, a, mask,
4311                 Int64VectorTests::UMINReduceMasked, Int64VectorTests::UMINReduceAllMasked);
4312     }
4313 
4314     static int UMAXReduce(int[] a, int idx) {
4315         int res = Integer.MIN_VALUE;
4316         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4317             res = (int) VectorMath.maxUnsigned(res, a[i]);
4318         }
4319 
4320         return res;
4321     }
4322 
4323     static int UMAXReduceAll(int[] a) {
4324         int res = Integer.MIN_VALUE;
4325         for (int i = 0; i < a.length; i += SPECIES.length()) {
4326             res = (int) VectorMath.maxUnsigned(res, UMAXReduce(a, i));
4327         }
4328 
4329         return res;
4330     }
4331 
4332     @Test(dataProvider = "intUnaryOpProvider")
4333     static void UMAXReduceInt64VectorTests(IntFunction<int[]> fa) {
4334         int[] a = fa.apply(SPECIES.length());
4335         int[] r = fr.apply(SPECIES.length());
4336         int ra = Integer.MIN_VALUE;
4337 
4338         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4339             for (int i = 0; i < a.length; i += SPECIES.length()) {
4340                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4341                 r[i] = av.reduceLanes(VectorOperators.UMAX);
4342             }
4343         }
4344 
4345         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4346             ra = Integer.MIN_VALUE;
4347             for (int i = 0; i < a.length; i += SPECIES.length()) {
4348                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4349                 ra = (int) VectorMath.maxUnsigned(ra, av.reduceLanes(VectorOperators.UMAX));
4350             }
4351         }
4352 
4353         assertReductionArraysEquals(r, ra, a,
4354                 Int64VectorTests::UMAXReduce, Int64VectorTests::UMAXReduceAll);
4355     }
4356 
4357     static int UMAXReduceMasked(int[] a, int idx, boolean[] mask) {
4358         int res = Integer.MIN_VALUE;
4359         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4360             if (mask[i % SPECIES.length()])
4361                 res = (int) VectorMath.maxUnsigned(res, a[i]);
4362         }
4363 
4364         return res;
4365     }
4366 
4367     static int UMAXReduceAllMasked(int[] a, boolean[] mask) {
4368         int res = Integer.MIN_VALUE;
4369         for (int i = 0; i < a.length; i += SPECIES.length()) {
4370             res = (int) VectorMath.maxUnsigned(res, UMAXReduceMasked(a, i, mask));
4371         }
4372 
4373         return res;
4374     }
4375 
4376     @Test(dataProvider = "intUnaryOpMaskProvider")
4377     static void UMAXReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4378         int[] a = fa.apply(SPECIES.length());
4379         int[] r = fr.apply(SPECIES.length());
4380         boolean[] mask = fm.apply(SPECIES.length());
4381         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4382         int ra = Integer.MIN_VALUE;
4383 
4384         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4385             for (int i = 0; i < a.length; i += SPECIES.length()) {
4386                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4387                 r[i] = av.reduceLanes(VectorOperators.UMAX, vmask);
4388             }
4389         }
4390 
4391         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4392             ra = Integer.MIN_VALUE;
4393             for (int i = 0; i < a.length; i += SPECIES.length()) {
4394                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4395                 ra = (int) VectorMath.maxUnsigned(ra, av.reduceLanes(VectorOperators.UMAX, vmask));
4396             }
4397         }
4398 
4399         assertReductionArraysEqualsMasked(r, ra, a, mask,
4400                 Int64VectorTests::UMAXReduceMasked, Int64VectorTests::UMAXReduceAllMasked);
4401     }
4402 
4403     static int FIRST_NONZEROReduce(int[] a, int idx) {
4404         int res = (int) 0;
4405         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4406             res = firstNonZero(res, a[i]);
4407         }
4408 
4409         return res;
4410     }
4411 
4412     static int FIRST_NONZEROReduceAll(int[] a) {
4413         int res = (int) 0;
4414         for (int i = 0; i < a.length; i += SPECIES.length()) {
4415             res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
4416         }
4417 
4418         return res;
4419     }
4420 
4421     @Test(dataProvider = "intUnaryOpProvider")
4422     static void FIRST_NONZEROReduceInt64VectorTests(IntFunction<int[]> fa) {
4423         int[] a = fa.apply(SPECIES.length());
4424         int[] r = fr.apply(SPECIES.length());
4425         int ra = (int) 0;
4426 
4427         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4428             for (int i = 0; i < a.length; i += SPECIES.length()) {
4429                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4430                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
4431             }
4432         }
4433 
4434         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4435             ra = (int) 0;
4436             for (int i = 0; i < a.length; i += SPECIES.length()) {
4437                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4438                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
4439             }
4440         }
4441 
4442         assertReductionArraysEquals(r, ra, a,
4443                 Int64VectorTests::FIRST_NONZEROReduce, Int64VectorTests::FIRST_NONZEROReduceAll);
4444     }
4445 
4446     static int FIRST_NONZEROReduceMasked(int[] a, int idx, boolean[] mask) {
4447         int res = (int) 0;
4448         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4449             if (mask[i % SPECIES.length()])
4450                 res = firstNonZero(res, a[i]);
4451         }
4452 
4453         return res;
4454     }
4455 
4456     static int FIRST_NONZEROReduceAllMasked(int[] a, boolean[] mask) {
4457         int res = (int) 0;
4458         for (int i = 0; i < a.length; i += SPECIES.length()) {
4459             res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
4460         }
4461 
4462         return res;
4463     }
4464 
4465     @Test(dataProvider = "intUnaryOpMaskProvider")
4466     static void FIRST_NONZEROReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4467         int[] a = fa.apply(SPECIES.length());
4468         int[] r = fr.apply(SPECIES.length());
4469         boolean[] mask = fm.apply(SPECIES.length());
4470         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4471         int ra = (int) 0;
4472 
4473         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4474             for (int i = 0; i < a.length; i += SPECIES.length()) {
4475                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4476                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
4477             }
4478         }
4479 
4480         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4481             ra = (int) 0;
4482             for (int i = 0; i < a.length; i += SPECIES.length()) {
4483                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4484                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
4485             }
4486         }
4487 
4488         assertReductionArraysEqualsMasked(r, ra, a, mask,
4489                 Int64VectorTests::FIRST_NONZEROReduceMasked, Int64VectorTests::FIRST_NONZEROReduceAllMasked);
4490     }
4491 
4492     static boolean anyTrue(boolean[] a, int idx) {
4493         boolean res = false;
4494         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4495             res |= a[i];
4496         }
4497 
4498         return res;
4499     }
4500 
4501     @Test(dataProvider = "boolUnaryOpProvider")
4502     static void anyTrueInt64VectorTests(IntFunction<boolean[]> fm) {
4503         boolean[] mask = fm.apply(SPECIES.length());
4504         boolean[] r = fmr.apply(SPECIES.length());
4505 
4506         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4507             for (int i = 0; i < mask.length; i += SPECIES.length()) {
4508                 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
4509                 r[i] = vmask.anyTrue();
4510             }
4511         }
4512 
4513         assertReductionBoolArraysEquals(r, mask, Int64VectorTests::anyTrue);
4514     }
4515 
4516     static boolean allTrue(boolean[] a, int idx) {
4517         boolean res = true;
4518         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4519             res &= a[i];
4520         }
4521 
4522         return res;
4523     }
4524 
4525     @Test(dataProvider = "boolUnaryOpProvider")
4526     static void allTrueInt64VectorTests(IntFunction<boolean[]> fm) {
4527         boolean[] mask = fm.apply(SPECIES.length());
4528         boolean[] r = fmr.apply(SPECIES.length());
4529 
4530         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4531             for (int i = 0; i < mask.length; i += SPECIES.length()) {
4532                 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
4533                 r[i] = vmask.allTrue();
4534             }
4535         }
4536 
4537         assertReductionBoolArraysEquals(r, mask, Int64VectorTests::allTrue);
4538     }
4539 
4540     static int SUADDReduce(int[] a, int idx) {
4541         int res = 0;
4542         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4543             res = (int) VectorMath.addSaturatingUnsigned(res, a[i]);
4544         }
4545 
4546         return res;
4547     }
4548 
4549     static int SUADDReduceAll(int[] a) {
4550         int res = 0;
4551         for (int i = 0; i < a.length; i += SPECIES.length()) {
4552             res = (int) VectorMath.addSaturatingUnsigned(res, SUADDReduce(a, i));
4553         }
4554 
4555         return res;
4556     }
4557 
4558     @Test(dataProvider = "intSaturatingUnaryOpProvider")
4559     static void SUADDReduceInt64VectorTests(IntFunction<int[]> fa) {
4560         int[] a = fa.apply(SPECIES.length());
4561         int[] r = fr.apply(SPECIES.length());
4562         int ra = 0;
4563 
4564         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4565             for (int i = 0; i < a.length; i += SPECIES.length()) {
4566                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4567                 r[i] = av.reduceLanes(VectorOperators.SUADD);
4568             }
4569         }
4570 
4571         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4572             ra = 0;
4573             for (int i = 0; i < a.length; i += SPECIES.length()) {
4574                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4575                 ra = (int) VectorMath.addSaturatingUnsigned(ra, av.reduceLanes(VectorOperators.SUADD));
4576             }
4577         }
4578 
4579         assertReductionArraysEquals(r, ra, a,
4580                 Int64VectorTests::SUADDReduce, Int64VectorTests::SUADDReduceAll);
4581     }
4582 
4583     static int SUADDReduceMasked(int[] a, int idx, boolean[] mask) {
4584         int res = 0;
4585         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4586             if (mask[i % SPECIES.length()])
4587                 res = (int) VectorMath.addSaturatingUnsigned(res, a[i]);
4588         }
4589 
4590         return res;
4591     }
4592 
4593     static int SUADDReduceAllMasked(int[] a, boolean[] mask) {
4594         int res = 0;
4595         for (int i = 0; i < a.length; i += SPECIES.length()) {
4596             res = (int) VectorMath.addSaturatingUnsigned(res, SUADDReduceMasked(a, i, mask));
4597         }
4598 
4599         return res;
4600     }
4601     @Test(dataProvider = "intSaturatingUnaryOpMaskProvider")
4602     static void SUADDReduceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4603         int[] a = fa.apply(SPECIES.length());
4604         int[] r = fr.apply(SPECIES.length());
4605         boolean[] mask = fm.apply(SPECIES.length());
4606         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4607         int ra = 0;
4608 
4609         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4610             for (int i = 0; i < a.length; i += SPECIES.length()) {
4611                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4612                 r[i] = av.reduceLanes(VectorOperators.SUADD, vmask);
4613             }
4614         }
4615 
4616         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4617             ra = 0;
4618             for (int i = 0; i < a.length; i += SPECIES.length()) {
4619                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4620                 ra = (int) VectorMath.addSaturatingUnsigned(ra, av.reduceLanes(VectorOperators.SUADD, vmask));
4621             }
4622         }
4623 
4624         assertReductionArraysEqualsMasked(r, ra, a, mask,
4625                 Int64VectorTests::SUADDReduceMasked, Int64VectorTests::SUADDReduceAllMasked);
4626     }
4627 
4628     @Test(dataProvider = "intBinaryOpProvider")
4629     static void withInt64VectorTests(IntFunction<int []> fa, IntFunction<int []> fb) {
4630         int[] a = fa.apply(SPECIES.length());
4631         int[] b = fb.apply(SPECIES.length());
4632         int[] r = fr.apply(SPECIES.length());
4633 
4634         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4635             for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
4636                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4637                 av.withLane(j, b[i + j]).intoArray(r, i);
4638                 a[i + j] = b[i + j];
4639                 j = (j + 1) & (SPECIES.length() - 1);
4640             }
4641         }
4642 
4643 
4644         assertArraysStrictlyEquals(r, a);
4645     }
4646 
4647     static boolean testIS_DEFAULT(int a) {
4648         return bits(a)==0;
4649     }
4650 
4651     @Test(dataProvider = "intTestOpProvider")
4652     static void IS_DEFAULTInt64VectorTests(IntFunction<int[]> fa) {
4653         int[] a = fa.apply(SPECIES.length());
4654 
4655         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4656             for (int i = 0; i < a.length; i += SPECIES.length()) {
4657                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4658                 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT);
4659 
4660                 // Check results as part of computation.
4661                 for (int j = 0; j < SPECIES.length(); j++) {
4662                     Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
4663                 }
4664             }
4665         }
4666     }
4667 
4668     @Test(dataProvider = "intTestOpMaskProvider")
4669     static void IS_DEFAULTMaskedInt64VectorTests(IntFunction<int[]> fa,
4670                                           IntFunction<boolean[]> fm) {
4671         int[] a = fa.apply(SPECIES.length());
4672         boolean[] mask = fm.apply(SPECIES.length());
4673         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4674 
4675         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4676             for (int i = 0; i < a.length; i += SPECIES.length()) {
4677                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4678                 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
4679 
4680                 // Check results as part of computation.
4681                 for (int j = 0; j < SPECIES.length(); j++) {
4682                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
4683                 }
4684             }
4685         }
4686     }
4687 
4688     static boolean testIS_NEGATIVE(int a) {
4689         return bits(a)<0;
4690     }
4691 
4692     @Test(dataProvider = "intTestOpProvider")
4693     static void IS_NEGATIVEInt64VectorTests(IntFunction<int[]> fa) {
4694         int[] a = fa.apply(SPECIES.length());
4695 
4696         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4697             for (int i = 0; i < a.length; i += SPECIES.length()) {
4698                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4699                 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE);
4700 
4701                 // Check results as part of computation.
4702                 for (int j = 0; j < SPECIES.length(); j++) {
4703                     Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
4704                 }
4705             }
4706         }
4707     }
4708 
4709     @Test(dataProvider = "intTestOpMaskProvider")
4710     static void IS_NEGATIVEMaskedInt64VectorTests(IntFunction<int[]> fa,
4711                                           IntFunction<boolean[]> fm) {
4712         int[] a = fa.apply(SPECIES.length());
4713         boolean[] mask = fm.apply(SPECIES.length());
4714         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4715 
4716         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4717             for (int i = 0; i < a.length; i += SPECIES.length()) {
4718                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4719                 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
4720 
4721                 // Check results as part of computation.
4722                 for (int j = 0; j < SPECIES.length(); j++) {
4723                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
4724                 }
4725             }
4726         }
4727     }
4728 
4729     @Test(dataProvider = "intCompareOpProvider")
4730     static void LTInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4731         int[] a = fa.apply(SPECIES.length());
4732         int[] b = fb.apply(SPECIES.length());
4733 
4734         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4735             for (int i = 0; i < a.length; i += SPECIES.length()) {
4736                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4737                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4738                 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv);
4739 
4740                 // Check results as part of computation.
4741                 for (int j = 0; j < SPECIES.length(); j++) {
4742                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
4743                 }
4744             }
4745         }
4746     }
4747 
4748     @Test(dataProvider = "intCompareOpProvider")
4749     static void ltInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4750         int[] a = fa.apply(SPECIES.length());
4751         int[] b = fb.apply(SPECIES.length());
4752 
4753         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4754             for (int i = 0; i < a.length; i += SPECIES.length()) {
4755                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4756                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4757                 VectorMask<Integer> mv = av.lt(bv);
4758 
4759                 // Check results as part of computation.
4760                 for (int j = 0; j < SPECIES.length(); j++) {
4761                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
4762                 }
4763             }
4764         }
4765     }
4766 
4767     @Test(dataProvider = "intCompareOpMaskProvider")
4768     static void LTInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4769                                                 IntFunction<boolean[]> fm) {
4770         int[] a = fa.apply(SPECIES.length());
4771         int[] b = fb.apply(SPECIES.length());
4772         boolean[] mask = fm.apply(SPECIES.length());
4773 
4774         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4775 
4776         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4777             for (int i = 0; i < a.length; i += SPECIES.length()) {
4778                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4779                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4780                 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv, vmask);
4781 
4782                 // Check results as part of computation.
4783                 for (int j = 0; j < SPECIES.length(); j++) {
4784                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
4785                 }
4786             }
4787         }
4788     }
4789 
4790     @Test(dataProvider = "intCompareOpProvider")
4791     static void GTInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4792         int[] a = fa.apply(SPECIES.length());
4793         int[] b = fb.apply(SPECIES.length());
4794 
4795         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4796             for (int i = 0; i < a.length; i += SPECIES.length()) {
4797                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4798                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4799                 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv);
4800 
4801                 // Check results as part of computation.
4802                 for (int j = 0; j < SPECIES.length(); j++) {
4803                     Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
4804                 }
4805             }
4806         }
4807     }
4808 
4809     @Test(dataProvider = "intCompareOpMaskProvider")
4810     static void GTInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4811                                                 IntFunction<boolean[]> fm) {
4812         int[] a = fa.apply(SPECIES.length());
4813         int[] b = fb.apply(SPECIES.length());
4814         boolean[] mask = fm.apply(SPECIES.length());
4815 
4816         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4817 
4818         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4819             for (int i = 0; i < a.length; i += SPECIES.length()) {
4820                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4821                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4822                 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv, vmask);
4823 
4824                 // Check results as part of computation.
4825                 for (int j = 0; j < SPECIES.length(); j++) {
4826                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
4827                 }
4828             }
4829         }
4830     }
4831 
4832     @Test(dataProvider = "intCompareOpProvider")
4833     static void EQInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4834         int[] a = fa.apply(SPECIES.length());
4835         int[] b = fb.apply(SPECIES.length());
4836 
4837         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4838             for (int i = 0; i < a.length; i += SPECIES.length()) {
4839                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4840                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4841                 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv);
4842 
4843                 // Check results as part of computation.
4844                 for (int j = 0; j < SPECIES.length(); j++) {
4845                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4846                 }
4847             }
4848         }
4849     }
4850 
4851     @Test(dataProvider = "intCompareOpProvider")
4852     static void eqInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4853         int[] a = fa.apply(SPECIES.length());
4854         int[] b = fb.apply(SPECIES.length());
4855 
4856         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4857             for (int i = 0; i < a.length; i += SPECIES.length()) {
4858                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4859                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4860                 VectorMask<Integer> mv = av.eq(bv);
4861 
4862                 // Check results as part of computation.
4863                 for (int j = 0; j < SPECIES.length(); j++) {
4864                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4865                 }
4866             }
4867         }
4868     }
4869 
4870     @Test(dataProvider = "intCompareOpMaskProvider")
4871     static void EQInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4872                                                 IntFunction<boolean[]> fm) {
4873         int[] a = fa.apply(SPECIES.length());
4874         int[] b = fb.apply(SPECIES.length());
4875         boolean[] mask = fm.apply(SPECIES.length());
4876 
4877         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4878 
4879         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4880             for (int i = 0; i < a.length; i += SPECIES.length()) {
4881                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4882                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4883                 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv, vmask);
4884 
4885                 // Check results as part of computation.
4886                 for (int j = 0; j < SPECIES.length(); j++) {
4887                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
4888                 }
4889             }
4890         }
4891     }
4892 
4893     @Test(dataProvider = "intCompareOpProvider")
4894     static void NEInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4895         int[] a = fa.apply(SPECIES.length());
4896         int[] b = fb.apply(SPECIES.length());
4897 
4898         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4899             for (int i = 0; i < a.length; i += SPECIES.length()) {
4900                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4901                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4902                 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv);
4903 
4904                 // Check results as part of computation.
4905                 for (int j = 0; j < SPECIES.length(); j++) {
4906                     Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
4907                 }
4908             }
4909         }
4910     }
4911 
4912     @Test(dataProvider = "intCompareOpMaskProvider")
4913     static void NEInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4914                                                 IntFunction<boolean[]> fm) {
4915         int[] a = fa.apply(SPECIES.length());
4916         int[] b = fb.apply(SPECIES.length());
4917         boolean[] mask = fm.apply(SPECIES.length());
4918 
4919         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4920 
4921         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4922             for (int i = 0; i < a.length; i += SPECIES.length()) {
4923                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4924                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4925                 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv, vmask);
4926 
4927                 // Check results as part of computation.
4928                 for (int j = 0; j < SPECIES.length(); j++) {
4929                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
4930                 }
4931             }
4932         }
4933     }
4934 
4935     @Test(dataProvider = "intCompareOpProvider")
4936     static void LEInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4937         int[] a = fa.apply(SPECIES.length());
4938         int[] b = fb.apply(SPECIES.length());
4939 
4940         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4941             for (int i = 0; i < a.length; i += SPECIES.length()) {
4942                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4943                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4944                 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv);
4945 
4946                 // Check results as part of computation.
4947                 for (int j = 0; j < SPECIES.length(); j++) {
4948                     Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
4949                 }
4950             }
4951         }
4952     }
4953 
4954     @Test(dataProvider = "intCompareOpMaskProvider")
4955     static void LEInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4956                                                 IntFunction<boolean[]> fm) {
4957         int[] a = fa.apply(SPECIES.length());
4958         int[] b = fb.apply(SPECIES.length());
4959         boolean[] mask = fm.apply(SPECIES.length());
4960 
4961         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4962 
4963         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4964             for (int i = 0; i < a.length; i += SPECIES.length()) {
4965                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4966                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4967                 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv, vmask);
4968 
4969                 // Check results as part of computation.
4970                 for (int j = 0; j < SPECIES.length(); j++) {
4971                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
4972                 }
4973             }
4974         }
4975     }
4976 
4977     @Test(dataProvider = "intCompareOpProvider")
4978     static void GEInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4979         int[] a = fa.apply(SPECIES.length());
4980         int[] b = fb.apply(SPECIES.length());
4981 
4982         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4983             for (int i = 0; i < a.length; i += SPECIES.length()) {
4984                 IntVector av = IntVector.fromArray(SPECIES, a, i);
4985                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4986                 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv);
4987 
4988                 // Check results as part of computation.
4989                 for (int j = 0; j < SPECIES.length(); j++) {
4990                     Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
4991                 }
4992             }
4993         }
4994     }
4995 
4996     @Test(dataProvider = "intCompareOpMaskProvider")
4997     static void GEInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4998                                                 IntFunction<boolean[]> fm) {
4999         int[] a = fa.apply(SPECIES.length());
5000         int[] b = fb.apply(SPECIES.length());
5001         boolean[] mask = fm.apply(SPECIES.length());
5002 
5003         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5004 
5005         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5006             for (int i = 0; i < a.length; i += SPECIES.length()) {
5007                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5008                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5009                 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv, vmask);
5010 
5011                 // Check results as part of computation.
5012                 for (int j = 0; j < SPECIES.length(); j++) {
5013                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
5014                 }
5015             }
5016         }
5017     }
5018 
5019     @Test(dataProvider = "intCompareOpProvider")
5020     static void ULTInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5021         int[] a = fa.apply(SPECIES.length());
5022         int[] b = fb.apply(SPECIES.length());
5023 
5024         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5025             for (int i = 0; i < a.length; i += SPECIES.length()) {
5026                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5027                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5028                 VectorMask<Integer> mv = av.compare(VectorOperators.ULT, bv);
5029 
5030                 // Check results as part of computation.
5031                 for (int j = 0; j < SPECIES.length(); j++) {
5032                     Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
5033                 }
5034             }
5035         }
5036     }
5037 
5038     @Test(dataProvider = "intCompareOpMaskProvider")
5039     static void ULTInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5040                                                 IntFunction<boolean[]> fm) {
5041         int[] a = fa.apply(SPECIES.length());
5042         int[] b = fb.apply(SPECIES.length());
5043         boolean[] mask = fm.apply(SPECIES.length());
5044 
5045         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5046 
5047         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5048             for (int i = 0; i < a.length; i += SPECIES.length()) {
5049                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5050                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5051                 VectorMask<Integer> mv = av.compare(VectorOperators.ULT, bv, vmask);
5052 
5053                 // Check results as part of computation.
5054                 for (int j = 0; j < SPECIES.length(); j++) {
5055                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
5056                 }
5057             }
5058         }
5059     }
5060 
5061     @Test(dataProvider = "intCompareOpProvider")
5062     static void UGTInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5063         int[] a = fa.apply(SPECIES.length());
5064         int[] b = fb.apply(SPECIES.length());
5065 
5066         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5067             for (int i = 0; i < a.length; i += SPECIES.length()) {
5068                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5069                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5070                 VectorMask<Integer> mv = av.compare(VectorOperators.UGT, bv);
5071 
5072                 // Check results as part of computation.
5073                 for (int j = 0; j < SPECIES.length(); j++) {
5074                     Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
5075                 }
5076             }
5077         }
5078     }
5079 
5080     @Test(dataProvider = "intCompareOpMaskProvider")
5081     static void UGTInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5082                                                 IntFunction<boolean[]> fm) {
5083         int[] a = fa.apply(SPECIES.length());
5084         int[] b = fb.apply(SPECIES.length());
5085         boolean[] mask = fm.apply(SPECIES.length());
5086 
5087         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5088 
5089         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5090             for (int i = 0; i < a.length; i += SPECIES.length()) {
5091                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5092                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5093                 VectorMask<Integer> mv = av.compare(VectorOperators.UGT, bv, vmask);
5094 
5095                 // Check results as part of computation.
5096                 for (int j = 0; j < SPECIES.length(); j++) {
5097                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
5098                 }
5099             }
5100         }
5101     }
5102 
5103     @Test(dataProvider = "intCompareOpProvider")
5104     static void ULEInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5105         int[] a = fa.apply(SPECIES.length());
5106         int[] b = fb.apply(SPECIES.length());
5107 
5108         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5109             for (int i = 0; i < a.length; i += SPECIES.length()) {
5110                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5111                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5112                 VectorMask<Integer> mv = av.compare(VectorOperators.ULE, bv);
5113 
5114                 // Check results as part of computation.
5115                 for (int j = 0; j < SPECIES.length(); j++) {
5116                     Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
5117                 }
5118             }
5119         }
5120     }
5121 
5122     @Test(dataProvider = "intCompareOpMaskProvider")
5123     static void ULEInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5124                                                 IntFunction<boolean[]> fm) {
5125         int[] a = fa.apply(SPECIES.length());
5126         int[] b = fb.apply(SPECIES.length());
5127         boolean[] mask = fm.apply(SPECIES.length());
5128 
5129         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5130 
5131         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5132             for (int i = 0; i < a.length; i += SPECIES.length()) {
5133                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5134                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5135                 VectorMask<Integer> mv = av.compare(VectorOperators.ULE, bv, vmask);
5136 
5137                 // Check results as part of computation.
5138                 for (int j = 0; j < SPECIES.length(); j++) {
5139                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j]));
5140                 }
5141             }
5142         }
5143     }
5144 
5145     @Test(dataProvider = "intCompareOpProvider")
5146     static void UGEInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5147         int[] a = fa.apply(SPECIES.length());
5148         int[] b = fb.apply(SPECIES.length());
5149 
5150         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5151             for (int i = 0; i < a.length; i += SPECIES.length()) {
5152                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5153                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5154                 VectorMask<Integer> mv = av.compare(VectorOperators.UGE, bv);
5155 
5156                 // Check results as part of computation.
5157                 for (int j = 0; j < SPECIES.length(); j++) {
5158                     Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
5159                 }
5160             }
5161         }
5162     }
5163 
5164     @Test(dataProvider = "intCompareOpMaskProvider")
5165     static void UGEInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5166                                                 IntFunction<boolean[]> fm) {
5167         int[] a = fa.apply(SPECIES.length());
5168         int[] b = fb.apply(SPECIES.length());
5169         boolean[] mask = fm.apply(SPECIES.length());
5170 
5171         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5172 
5173         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5174             for (int i = 0; i < a.length; i += SPECIES.length()) {
5175                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5176                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5177                 VectorMask<Integer> mv = av.compare(VectorOperators.UGE, bv, vmask);
5178 
5179                 // Check results as part of computation.
5180                 for (int j = 0; j < SPECIES.length(); j++) {
5181                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
5182                 }
5183             }
5184         }
5185     }
5186 
5187     @Test(dataProvider = "intCompareOpProvider")
5188     static void LTInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5189         int[] a = fa.apply(SPECIES.length());
5190         int[] b = fb.apply(SPECIES.length());
5191 
5192         for (int i = 0; i < a.length; i += SPECIES.length()) {
5193             IntVector av = IntVector.fromArray(SPECIES, a, i);
5194             VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i]);
5195 
5196             // Check results as part of computation.
5197             for (int j = 0; j < SPECIES.length(); j++) {
5198                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
5199             }
5200         }
5201     }
5202 
5203     @Test(dataProvider = "intCompareOpMaskProvider")
5204     static void LTInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa,
5205                                 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5206         int[] a = fa.apply(SPECIES.length());
5207         int[] b = fb.apply(SPECIES.length());
5208         boolean[] mask = fm.apply(SPECIES.length());
5209 
5210         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5211 
5212         for (int i = 0; i < a.length; i += SPECIES.length()) {
5213             IntVector av = IntVector.fromArray(SPECIES, a, i);
5214             VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i], vmask);
5215 
5216             // Check results as part of computation.
5217             for (int j = 0; j < SPECIES.length(); j++) {
5218                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
5219             }
5220         }
5221     }
5222 
5223     @Test(dataProvider = "intCompareOpProvider")
5224     static void LTInt64VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5225         int[] a = fa.apply(SPECIES.length());
5226         int[] b = fb.apply(SPECIES.length());
5227 
5228         for (int i = 0; i < a.length; i += SPECIES.length()) {
5229             IntVector av = IntVector.fromArray(SPECIES, a, i);
5230             VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i]);
5231 
5232             // Check results as part of computation.
5233             for (int j = 0; j < SPECIES.length(); j++) {
5234                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (int)((long)b[i]));
5235             }
5236         }
5237     }
5238 
5239     @Test(dataProvider = "intCompareOpMaskProvider")
5240     static void LTInt64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa,
5241                                 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5242         int[] a = fa.apply(SPECIES.length());
5243         int[] b = fb.apply(SPECIES.length());
5244         boolean[] mask = fm.apply(SPECIES.length());
5245 
5246         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5247 
5248         for (int i = 0; i < a.length; i += SPECIES.length()) {
5249             IntVector av = IntVector.fromArray(SPECIES, a, i);
5250             VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
5251 
5252             // Check results as part of computation.
5253             for (int j = 0; j < SPECIES.length(); j++) {
5254                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (int)((long)b[i])));
5255             }
5256         }
5257     }
5258 
5259     @Test(dataProvider = "intCompareOpProvider")
5260     static void EQInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5261         int[] a = fa.apply(SPECIES.length());
5262         int[] b = fb.apply(SPECIES.length());
5263 
5264         for (int i = 0; i < a.length; i += SPECIES.length()) {
5265             IntVector av = IntVector.fromArray(SPECIES, a, i);
5266             VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i]);
5267 
5268             // Check results as part of computation.
5269             for (int j = 0; j < SPECIES.length(); j++) {
5270                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
5271             }
5272         }
5273     }
5274 
5275     @Test(dataProvider = "intCompareOpMaskProvider")
5276     static void EQInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa,
5277                                 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5278         int[] a = fa.apply(SPECIES.length());
5279         int[] b = fb.apply(SPECIES.length());
5280         boolean[] mask = fm.apply(SPECIES.length());
5281 
5282         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5283 
5284         for (int i = 0; i < a.length; i += SPECIES.length()) {
5285             IntVector av = IntVector.fromArray(SPECIES, a, i);
5286             VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i], vmask);
5287 
5288             // Check results as part of computation.
5289             for (int j = 0; j < SPECIES.length(); j++) {
5290                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
5291             }
5292         }
5293     }
5294 
5295     @Test(dataProvider = "intCompareOpProvider")
5296     static void EQInt64VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5297         int[] a = fa.apply(SPECIES.length());
5298         int[] b = fb.apply(SPECIES.length());
5299 
5300         for (int i = 0; i < a.length; i += SPECIES.length()) {
5301             IntVector av = IntVector.fromArray(SPECIES, a, i);
5302             VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i]);
5303 
5304             // Check results as part of computation.
5305             for (int j = 0; j < SPECIES.length(); j++) {
5306                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (int)((long)b[i]));
5307             }
5308         }
5309     }
5310 
5311     @Test(dataProvider = "intCompareOpMaskProvider")
5312     static void EQInt64VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa,
5313                                 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5314         int[] a = fa.apply(SPECIES.length());
5315         int[] b = fb.apply(SPECIES.length());
5316         boolean[] mask = fm.apply(SPECIES.length());
5317 
5318         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5319 
5320         for (int i = 0; i < a.length; i += SPECIES.length()) {
5321             IntVector av = IntVector.fromArray(SPECIES, a, i);
5322             VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
5323 
5324             // Check results as part of computation.
5325             for (int j = 0; j < SPECIES.length(); j++) {
5326                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (int)((long)b[i])));
5327             }
5328         }
5329     }
5330 
5331     static int blend(int a, int b, boolean mask) {
5332         return mask ? b : a;
5333     }
5334 
5335     @Test(dataProvider = "intBinaryOpMaskProvider")
5336     static void blendInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
5337                                           IntFunction<boolean[]> fm) {
5338         int[] a = fa.apply(SPECIES.length());
5339         int[] b = fb.apply(SPECIES.length());
5340         int[] r = fr.apply(SPECIES.length());
5341         boolean[] mask = fm.apply(SPECIES.length());
5342         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5343 
5344         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5345             for (int i = 0; i < a.length; i += SPECIES.length()) {
5346                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5347                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5348                 av.blend(bv, vmask).intoArray(r, i);
5349             }
5350         }
5351 
5352         assertArraysEquals(r, a, b, mask, Int64VectorTests::blend);
5353     }
5354 
5355     @Test(dataProvider = "intUnaryOpShuffleProvider")
5356     static void RearrangeInt64VectorTests(IntFunction<int[]> fa,
5357                                            BiFunction<Integer,Integer,int[]> fs) {
5358         int[] a = fa.apply(SPECIES.length());
5359         int[] order = fs.apply(a.length, SPECIES.length());
5360         int[] r = fr.apply(SPECIES.length());
5361 
5362         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5363             for (int i = 0; i < a.length; i += SPECIES.length()) {
5364                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5365                 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
5366             }
5367         }
5368 
5369         assertRearrangeArraysEquals(r, a, order, SPECIES.length());
5370     }
5371 
5372     @Test(dataProvider = "intUnaryOpShuffleMaskProvider")
5373     static void RearrangeInt64VectorTestsMaskedSmokeTest(IntFunction<int[]> fa,
5374                                                           BiFunction<Integer,Integer,int[]> fs,
5375                                                           IntFunction<boolean[]> fm) {
5376         int[] a = fa.apply(SPECIES.length());
5377         int[] order = fs.apply(a.length, SPECIES.length());
5378         int[] r = fr.apply(SPECIES.length());
5379         boolean[] mask = fm.apply(SPECIES.length());
5380         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5381 
5382         for (int i = 0; i < a.length; i += SPECIES.length()) {
5383             IntVector av = IntVector.fromArray(SPECIES, a, i);
5384             av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
5385         }
5386 
5387         assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
5388     }
5389 
5390     @Test(dataProvider = "intUnaryOpMaskProvider")
5391     static void compressInt64VectorTests(IntFunction<int[]> fa,
5392                                                 IntFunction<boolean[]> fm) {
5393         int[] a = fa.apply(SPECIES.length());
5394         int[] r = fr.apply(SPECIES.length());
5395         boolean[] mask = fm.apply(SPECIES.length());
5396         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5397 
5398         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5399             for (int i = 0; i < a.length; i += SPECIES.length()) {
5400                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5401                 av.compress(vmask).intoArray(r, i);
5402             }
5403         }
5404 
5405         assertcompressArraysEquals(r, a, mask, SPECIES.length());
5406     }
5407 
5408     @Test(dataProvider = "intUnaryOpMaskProvider")
5409     static void expandInt64VectorTests(IntFunction<int[]> fa,
5410                                                 IntFunction<boolean[]> fm) {
5411         int[] a = fa.apply(SPECIES.length());
5412         int[] r = fr.apply(SPECIES.length());
5413         boolean[] mask = fm.apply(SPECIES.length());
5414         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5415 
5416         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5417             for (int i = 0; i < a.length; i += SPECIES.length()) {
5418                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5419                 av.expand(vmask).intoArray(r, i);
5420             }
5421         }
5422 
5423         assertexpandArraysEquals(r, a, mask, SPECIES.length());
5424     }
5425 
5426     @Test(dataProvider = "intUnaryOpProvider")
5427     static void getInt64VectorTests(IntFunction<int[]> fa) {
5428         int[] a = fa.apply(SPECIES.length());
5429         int[] r = fr.apply(SPECIES.length());
5430 
5431         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5432             for (int i = 0; i < a.length; i += SPECIES.length()) {
5433                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5434                 int num_lanes = SPECIES.length();
5435                 // Manually unroll because full unroll happens after intrinsification.
5436                 // Unroll is needed because get intrinsic requires for index to be a known constant.
5437                 if (num_lanes == 1) {
5438                     r[i]=av.lane(0);
5439                 } else if (num_lanes == 2) {
5440                     r[i]=av.lane(0);
5441                     r[i+1]=av.lane(1);
5442                 } else if (num_lanes == 4) {
5443                     r[i]=av.lane(0);
5444                     r[i+1]=av.lane(1);
5445                     r[i+2]=av.lane(2);
5446                     r[i+3]=av.lane(3);
5447                 } else if (num_lanes == 8) {
5448                     r[i]=av.lane(0);
5449                     r[i+1]=av.lane(1);
5450                     r[i+2]=av.lane(2);
5451                     r[i+3]=av.lane(3);
5452                     r[i+4]=av.lane(4);
5453                     r[i+5]=av.lane(5);
5454                     r[i+6]=av.lane(6);
5455                     r[i+7]=av.lane(7);
5456                 } else if (num_lanes == 16) {
5457                     r[i]=av.lane(0);
5458                     r[i+1]=av.lane(1);
5459                     r[i+2]=av.lane(2);
5460                     r[i+3]=av.lane(3);
5461                     r[i+4]=av.lane(4);
5462                     r[i+5]=av.lane(5);
5463                     r[i+6]=av.lane(6);
5464                     r[i+7]=av.lane(7);
5465                     r[i+8]=av.lane(8);
5466                     r[i+9]=av.lane(9);
5467                     r[i+10]=av.lane(10);
5468                     r[i+11]=av.lane(11);
5469                     r[i+12]=av.lane(12);
5470                     r[i+13]=av.lane(13);
5471                     r[i+14]=av.lane(14);
5472                     r[i+15]=av.lane(15);
5473                 } else if (num_lanes == 32) {
5474                     r[i]=av.lane(0);
5475                     r[i+1]=av.lane(1);
5476                     r[i+2]=av.lane(2);
5477                     r[i+3]=av.lane(3);
5478                     r[i+4]=av.lane(4);
5479                     r[i+5]=av.lane(5);
5480                     r[i+6]=av.lane(6);
5481                     r[i+7]=av.lane(7);
5482                     r[i+8]=av.lane(8);
5483                     r[i+9]=av.lane(9);
5484                     r[i+10]=av.lane(10);
5485                     r[i+11]=av.lane(11);
5486                     r[i+12]=av.lane(12);
5487                     r[i+13]=av.lane(13);
5488                     r[i+14]=av.lane(14);
5489                     r[i+15]=av.lane(15);
5490                     r[i+16]=av.lane(16);
5491                     r[i+17]=av.lane(17);
5492                     r[i+18]=av.lane(18);
5493                     r[i+19]=av.lane(19);
5494                     r[i+20]=av.lane(20);
5495                     r[i+21]=av.lane(21);
5496                     r[i+22]=av.lane(22);
5497                     r[i+23]=av.lane(23);
5498                     r[i+24]=av.lane(24);
5499                     r[i+25]=av.lane(25);
5500                     r[i+26]=av.lane(26);
5501                     r[i+27]=av.lane(27);
5502                     r[i+28]=av.lane(28);
5503                     r[i+29]=av.lane(29);
5504                     r[i+30]=av.lane(30);
5505                     r[i+31]=av.lane(31);
5506                 } else if (num_lanes == 64) {
5507                     r[i]=av.lane(0);
5508                     r[i+1]=av.lane(1);
5509                     r[i+2]=av.lane(2);
5510                     r[i+3]=av.lane(3);
5511                     r[i+4]=av.lane(4);
5512                     r[i+5]=av.lane(5);
5513                     r[i+6]=av.lane(6);
5514                     r[i+7]=av.lane(7);
5515                     r[i+8]=av.lane(8);
5516                     r[i+9]=av.lane(9);
5517                     r[i+10]=av.lane(10);
5518                     r[i+11]=av.lane(11);
5519                     r[i+12]=av.lane(12);
5520                     r[i+13]=av.lane(13);
5521                     r[i+14]=av.lane(14);
5522                     r[i+15]=av.lane(15);
5523                     r[i+16]=av.lane(16);
5524                     r[i+17]=av.lane(17);
5525                     r[i+18]=av.lane(18);
5526                     r[i+19]=av.lane(19);
5527                     r[i+20]=av.lane(20);
5528                     r[i+21]=av.lane(21);
5529                     r[i+22]=av.lane(22);
5530                     r[i+23]=av.lane(23);
5531                     r[i+24]=av.lane(24);
5532                     r[i+25]=av.lane(25);
5533                     r[i+26]=av.lane(26);
5534                     r[i+27]=av.lane(27);
5535                     r[i+28]=av.lane(28);
5536                     r[i+29]=av.lane(29);
5537                     r[i+30]=av.lane(30);
5538                     r[i+31]=av.lane(31);
5539                     r[i+32]=av.lane(32);
5540                     r[i+33]=av.lane(33);
5541                     r[i+34]=av.lane(34);
5542                     r[i+35]=av.lane(35);
5543                     r[i+36]=av.lane(36);
5544                     r[i+37]=av.lane(37);
5545                     r[i+38]=av.lane(38);
5546                     r[i+39]=av.lane(39);
5547                     r[i+40]=av.lane(40);
5548                     r[i+41]=av.lane(41);
5549                     r[i+42]=av.lane(42);
5550                     r[i+43]=av.lane(43);
5551                     r[i+44]=av.lane(44);
5552                     r[i+45]=av.lane(45);
5553                     r[i+46]=av.lane(46);
5554                     r[i+47]=av.lane(47);
5555                     r[i+48]=av.lane(48);
5556                     r[i+49]=av.lane(49);
5557                     r[i+50]=av.lane(50);
5558                     r[i+51]=av.lane(51);
5559                     r[i+52]=av.lane(52);
5560                     r[i+53]=av.lane(53);
5561                     r[i+54]=av.lane(54);
5562                     r[i+55]=av.lane(55);
5563                     r[i+56]=av.lane(56);
5564                     r[i+57]=av.lane(57);
5565                     r[i+58]=av.lane(58);
5566                     r[i+59]=av.lane(59);
5567                     r[i+60]=av.lane(60);
5568                     r[i+61]=av.lane(61);
5569                     r[i+62]=av.lane(62);
5570                     r[i+63]=av.lane(63);
5571                 } else {
5572                     for (int j = 0; j < SPECIES.length(); j++) {
5573                         r[i+j]=av.lane(j);
5574                     }
5575                 }
5576             }
5577         }
5578 
5579         assertArraysStrictlyEquals(r, a);
5580     }
5581 
5582     @Test(dataProvider = "intUnaryOpProvider")
5583     static void BroadcastInt64VectorTests(IntFunction<int[]> fa) {
5584         int[] a = fa.apply(SPECIES.length());
5585         int[] r = new int[a.length];
5586 
5587         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5588             for (int i = 0; i < a.length; i += SPECIES.length()) {
5589                 IntVector.broadcast(SPECIES, a[i]).intoArray(r, i);
5590             }
5591         }
5592 
5593         assertBroadcastArraysEquals(r, a);
5594     }
5595 
5596     @Test(dataProvider = "intUnaryOpProvider")
5597     static void ZeroInt64VectorTests(IntFunction<int[]> fa) {
5598         int[] a = fa.apply(SPECIES.length());
5599         int[] r = new int[a.length];
5600 
5601         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5602             for (int i = 0; i < a.length; i += SPECIES.length()) {
5603                 IntVector.zero(SPECIES).intoArray(a, i);
5604             }
5605         }
5606 
5607         Assert.assertEquals(a, r);
5608     }
5609 
5610     static int[] sliceUnary(int[] a, int origin, int idx) {
5611         int[] res = new int[SPECIES.length()];
5612         for (int i = 0; i < SPECIES.length(); i++){
5613             if(i+origin < SPECIES.length())
5614                 res[i] = a[idx+i+origin];
5615             else
5616                 res[i] = (int)0;
5617         }
5618         return res;
5619     }
5620 
5621     @Test(dataProvider = "intUnaryOpProvider")
5622     static void sliceUnaryInt64VectorTests(IntFunction<int[]> fa) {
5623         int[] a = fa.apply(SPECIES.length());
5624         int[] r = new int[a.length];
5625         int origin = RAND.nextInt(SPECIES.length());
5626         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5627             for (int i = 0; i < a.length; i += SPECIES.length()) {
5628                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5629                 av.slice(origin).intoArray(r, i);
5630             }
5631         }
5632 
5633         assertArraysEquals(r, a, origin, Int64VectorTests::sliceUnary);
5634     }
5635 
5636     static int[] sliceBinary(int[] a, int[] b, int origin, int idx) {
5637         int[] res = new int[SPECIES.length()];
5638         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5639             if(i+origin < SPECIES.length())
5640                 res[i] = a[idx+i+origin];
5641             else {
5642                 res[i] = b[idx+j];
5643                 j++;
5644             }
5645         }
5646         return res;
5647     }
5648 
5649     @Test(dataProvider = "intBinaryOpProvider")
5650     static void sliceBinaryInt64VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5651         int[] a = fa.apply(SPECIES.length());
5652         int[] b = fb.apply(SPECIES.length());
5653         int[] r = new int[a.length];
5654         int origin = RAND.nextInt(SPECIES.length());
5655         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5656             for (int i = 0; i < a.length; i += SPECIES.length()) {
5657                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5658                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5659                 av.slice(origin, bv).intoArray(r, i);
5660             }
5661         }
5662 
5663         assertArraysEquals(r, a, b, origin, Int64VectorTests::sliceBinary);
5664     }
5665 
5666     static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) {
5667         int[] res = new int[SPECIES.length()];
5668         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5669             if(i+origin < SPECIES.length())
5670                 res[i] = mask[i] ? a[idx+i+origin] : (int)0;
5671             else {
5672                 res[i] = mask[i] ? b[idx+j] : (int)0;
5673                 j++;
5674             }
5675         }
5676         return res;
5677     }
5678 
5679     @Test(dataProvider = "intBinaryOpMaskProvider")
5680     static void sliceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5681     IntFunction<boolean[]> fm) {
5682         int[] a = fa.apply(SPECIES.length());
5683         int[] b = fb.apply(SPECIES.length());
5684         boolean[] mask = fm.apply(SPECIES.length());
5685         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5686 
5687         int[] r = new int[a.length];
5688         int origin = RAND.nextInt(SPECIES.length());
5689         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5690             for (int i = 0; i < a.length; i += SPECIES.length()) {
5691                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5692                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5693                 av.slice(origin, bv, vmask).intoArray(r, i);
5694             }
5695         }
5696 
5697         assertArraysEquals(r, a, b, origin, mask, Int64VectorTests::slice);
5698     }
5699 
5700     static int[] unsliceUnary(int[] a, int origin, int idx) {
5701         int[] res = new int[SPECIES.length()];
5702         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5703             if(i < origin)
5704                 res[i] = (int)0;
5705             else {
5706                 res[i] = a[idx+j];
5707                 j++;
5708             }
5709         }
5710         return res;
5711     }
5712 
5713     @Test(dataProvider = "intUnaryOpProvider")
5714     static void unsliceUnaryInt64VectorTests(IntFunction<int[]> fa) {
5715         int[] a = fa.apply(SPECIES.length());
5716         int[] r = new int[a.length];
5717         int origin = RAND.nextInt(SPECIES.length());
5718         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5719             for (int i = 0; i < a.length; i += SPECIES.length()) {
5720                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5721                 av.unslice(origin).intoArray(r, i);
5722             }
5723         }
5724 
5725         assertArraysEquals(r, a, origin, Int64VectorTests::unsliceUnary);
5726     }
5727 
5728     static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) {
5729         int[] res = new int[SPECIES.length()];
5730         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5731             if (part == 0) {
5732                 if (i < origin)
5733                     res[i] = b[idx+i];
5734                 else {
5735                     res[i] = a[idx+j];
5736                     j++;
5737                 }
5738             } else if (part == 1) {
5739                 if (i < origin)
5740                     res[i] = a[idx+SPECIES.length()-origin+i];
5741                 else {
5742                     res[i] = b[idx+origin+j];
5743                     j++;
5744                 }
5745             }
5746         }
5747         return res;
5748     }
5749 
5750     @Test(dataProvider = "intBinaryOpProvider")
5751     static void unsliceBinaryInt64VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5752         int[] a = fa.apply(SPECIES.length());
5753         int[] b = fb.apply(SPECIES.length());
5754         int[] r = new int[a.length];
5755         int origin = RAND.nextInt(SPECIES.length());
5756         int part = RAND.nextInt(2);
5757         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5758             for (int i = 0; i < a.length; i += SPECIES.length()) {
5759                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5760                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5761                 av.unslice(origin, bv, part).intoArray(r, i);
5762             }
5763         }
5764 
5765         assertArraysEquals(r, a, b, origin, part, Int64VectorTests::unsliceBinary);
5766     }
5767 
5768     static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) {
5769         int[] res = new int[SPECIES.length()];
5770         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5771             if(i+origin < SPECIES.length())
5772                 res[i] = b[idx+i+origin];
5773             else {
5774                 res[i] = b[idx+j];
5775                 j++;
5776             }
5777         }
5778         for (int i = 0; i < SPECIES.length(); i++){
5779             res[i] = mask[i] ? a[idx+i] : res[i];
5780         }
5781         int[] res1 = new int[SPECIES.length()];
5782         if (part == 0) {
5783             for (int i = 0, j = 0; i < SPECIES.length(); i++){
5784                 if (i < origin)
5785                     res1[i] = b[idx+i];
5786                 else {
5787                    res1[i] = res[j];
5788                    j++;
5789                 }
5790             }
5791         } else if (part == 1) {
5792             for (int i = 0, j = 0; i < SPECIES.length(); i++){
5793                 if (i < origin)
5794                     res1[i] = res[SPECIES.length()-origin+i];
5795                 else {
5796                     res1[i] = b[idx+origin+j];
5797                     j++;
5798                 }
5799             }
5800         }
5801         return res1;
5802     }
5803 
5804     @Test(dataProvider = "intBinaryOpMaskProvider")
5805     static void unsliceInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5806     IntFunction<boolean[]> fm) {
5807         int[] a = fa.apply(SPECIES.length());
5808         int[] b = fb.apply(SPECIES.length());
5809         boolean[] mask = fm.apply(SPECIES.length());
5810         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5811         int[] r = new int[a.length];
5812         int origin = RAND.nextInt(SPECIES.length());
5813         int part = RAND.nextInt(2);
5814         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5815             for (int i = 0; i < a.length; i += SPECIES.length()) {
5816                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5817                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5818                 av.unslice(origin, bv, part, vmask).intoArray(r, i);
5819             }
5820         }
5821 
5822         assertArraysEquals(r, a, b, origin, part, mask, Int64VectorTests::unslice);
5823     }
5824 
5825     static int BITWISE_BLEND(int a, int b, int c) {
5826         return (int)((a&~(c))|(b&c));
5827     }
5828 
5829     static int bitwiseBlend(int a, int b, int c) {
5830         return (int)((a&~(c))|(b&c));
5831     }
5832 
5833     @Test(dataProvider = "intTernaryOpProvider")
5834     static void BITWISE_BLENDInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5835         int[] a = fa.apply(SPECIES.length());
5836         int[] b = fb.apply(SPECIES.length());
5837         int[] c = fc.apply(SPECIES.length());
5838         int[] r = fr.apply(SPECIES.length());
5839 
5840         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5841             for (int i = 0; i < a.length; i += SPECIES.length()) {
5842                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5843                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5844                 IntVector cv = IntVector.fromArray(SPECIES, c, i);
5845                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
5846             }
5847         }
5848 
5849         assertArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND);
5850     }
5851 
5852     @Test(dataProvider = "intTernaryOpProvider")
5853     static void bitwiseBlendInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5854         int[] a = fa.apply(SPECIES.length());
5855         int[] b = fb.apply(SPECIES.length());
5856         int[] c = fc.apply(SPECIES.length());
5857         int[] r = fr.apply(SPECIES.length());
5858 
5859         for (int i = 0; i < a.length; i += SPECIES.length()) {
5860             IntVector av = IntVector.fromArray(SPECIES, a, i);
5861             IntVector bv = IntVector.fromArray(SPECIES, b, i);
5862             IntVector cv = IntVector.fromArray(SPECIES, c, i);
5863             av.bitwiseBlend(bv, cv).intoArray(r, i);
5864         }
5865 
5866         assertArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend);
5867     }
5868 
5869     @Test(dataProvider = "intTernaryOpMaskProvider")
5870     static void BITWISE_BLENDInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5871                                           IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
5872         int[] a = fa.apply(SPECIES.length());
5873         int[] b = fb.apply(SPECIES.length());
5874         int[] c = fc.apply(SPECIES.length());
5875         int[] r = fr.apply(SPECIES.length());
5876         boolean[] mask = fm.apply(SPECIES.length());
5877         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5878 
5879         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5880             for (int i = 0; i < a.length; i += SPECIES.length()) {
5881                 IntVector av = IntVector.fromArray(SPECIES, a, i);
5882                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5883                 IntVector cv = IntVector.fromArray(SPECIES, c, i);
5884                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
5885             }
5886         }
5887 
5888         assertArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND);
5889     }
5890 
5891     @Test(dataProvider = "intTernaryOpProvider")
5892     static void BITWISE_BLENDInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5893         int[] a = fa.apply(SPECIES.length());
5894         int[] b = fb.apply(SPECIES.length());
5895         int[] c = fc.apply(SPECIES.length());
5896         int[] r = fr.apply(SPECIES.length());
5897 
5898         for (int i = 0; i < a.length; i += SPECIES.length()) {
5899             IntVector av = IntVector.fromArray(SPECIES, a, i);
5900             IntVector bv = IntVector.fromArray(SPECIES, b, i);
5901             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
5902         }
5903         assertBroadcastArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND);
5904     }
5905 
5906     @Test(dataProvider = "intTernaryOpProvider")
5907     static void BITWISE_BLENDInt64VectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5908         int[] a = fa.apply(SPECIES.length());
5909         int[] b = fb.apply(SPECIES.length());
5910         int[] c = fc.apply(SPECIES.length());
5911         int[] r = fr.apply(SPECIES.length());
5912 
5913         for (int i = 0; i < a.length; i += SPECIES.length()) {
5914             IntVector av = IntVector.fromArray(SPECIES, a, i);
5915             IntVector cv = IntVector.fromArray(SPECIES, c, i);
5916             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
5917         }
5918         assertAltBroadcastArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND);
5919     }
5920 
5921     @Test(dataProvider = "intTernaryOpProvider")
5922     static void bitwiseBlendInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5923         int[] a = fa.apply(SPECIES.length());
5924         int[] b = fb.apply(SPECIES.length());
5925         int[] c = fc.apply(SPECIES.length());
5926         int[] r = fr.apply(SPECIES.length());
5927 
5928         for (int i = 0; i < a.length; i += SPECIES.length()) {
5929             IntVector av = IntVector.fromArray(SPECIES, a, i);
5930             IntVector bv = IntVector.fromArray(SPECIES, b, i);
5931             av.bitwiseBlend(bv, c[i]).intoArray(r, i);
5932         }
5933         assertBroadcastArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend);
5934     }
5935 
5936     @Test(dataProvider = "intTernaryOpProvider")
5937     static void bitwiseBlendInt64VectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5938         int[] a = fa.apply(SPECIES.length());
5939         int[] b = fb.apply(SPECIES.length());
5940         int[] c = fc.apply(SPECIES.length());
5941         int[] r = fr.apply(SPECIES.length());
5942 
5943         for (int i = 0; i < a.length; i += SPECIES.length()) {
5944             IntVector av = IntVector.fromArray(SPECIES, a, i);
5945             IntVector cv = IntVector.fromArray(SPECIES, c, i);
5946             av.bitwiseBlend(b[i], cv).intoArray(r, i);
5947         }
5948         assertAltBroadcastArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend);
5949     }
5950 
5951     @Test(dataProvider = "intTernaryOpMaskProvider")
5952     static void BITWISE_BLENDInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
5953                                           IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
5954         int[] a = fa.apply(SPECIES.length());
5955         int[] b = fb.apply(SPECIES.length());
5956         int[] c = fc.apply(SPECIES.length());
5957         int[] r = fr.apply(SPECIES.length());
5958         boolean[] mask = fm.apply(SPECIES.length());
5959         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5960 
5961         for (int i = 0; i < a.length; i += SPECIES.length()) {
5962             IntVector av = IntVector.fromArray(SPECIES, a, i);
5963             IntVector bv = IntVector.fromArray(SPECIES, b, i);
5964             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
5965         }
5966 
5967         assertBroadcastArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND);
5968     }
5969 
5970     @Test(dataProvider = "intTernaryOpMaskProvider")
5971     static void BITWISE_BLENDInt64VectorTestsAltBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
5972                                           IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
5973         int[] a = fa.apply(SPECIES.length());
5974         int[] b = fb.apply(SPECIES.length());
5975         int[] c = fc.apply(SPECIES.length());
5976         int[] r = fr.apply(SPECIES.length());
5977         boolean[] mask = fm.apply(SPECIES.length());
5978         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5979 
5980         for (int i = 0; i < a.length; i += SPECIES.length()) {
5981             IntVector av = IntVector.fromArray(SPECIES, a, i);
5982             IntVector cv = IntVector.fromArray(SPECIES, c, i);
5983             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
5984         }
5985 
5986         assertAltBroadcastArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND);
5987     }
5988 
5989     @Test(dataProvider = "intTernaryOpProvider")
5990     static void BITWISE_BLENDInt64VectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5991         int[] a = fa.apply(SPECIES.length());
5992         int[] b = fb.apply(SPECIES.length());
5993         int[] c = fc.apply(SPECIES.length());
5994         int[] r = fr.apply(SPECIES.length());
5995 
5996         for (int i = 0; i < a.length; i += SPECIES.length()) {
5997             IntVector av = IntVector.fromArray(SPECIES, a, i);
5998             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
5999         }
6000 
6001         assertDoubleBroadcastArraysEquals(r, a, b, c, Int64VectorTests::BITWISE_BLEND);
6002     }
6003 
6004     @Test(dataProvider = "intTernaryOpProvider")
6005     static void bitwiseBlendInt64VectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
6006         int[] a = fa.apply(SPECIES.length());
6007         int[] b = fb.apply(SPECIES.length());
6008         int[] c = fc.apply(SPECIES.length());
6009         int[] r = fr.apply(SPECIES.length());
6010 
6011         for (int i = 0; i < a.length; i += SPECIES.length()) {
6012             IntVector av = IntVector.fromArray(SPECIES, a, i);
6013             av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
6014         }
6015 
6016         assertDoubleBroadcastArraysEquals(r, a, b, c, Int64VectorTests::bitwiseBlend);
6017     }
6018 
6019     @Test(dataProvider = "intTernaryOpMaskProvider")
6020     static void BITWISE_BLENDInt64VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
6021                                           IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
6022         int[] a = fa.apply(SPECIES.length());
6023         int[] b = fb.apply(SPECIES.length());
6024         int[] c = fc.apply(SPECIES.length());
6025         int[] r = fr.apply(SPECIES.length());
6026         boolean[] mask = fm.apply(SPECIES.length());
6027         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6028 
6029         for (int i = 0; i < a.length; i += SPECIES.length()) {
6030             IntVector av = IntVector.fromArray(SPECIES, a, i);
6031             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
6032         }
6033 
6034         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Int64VectorTests::BITWISE_BLEND);
6035     }
6036 
6037     static int NEG(int a) {
6038         return (int)(-((int)a));
6039     }
6040 
6041     static int neg(int a) {
6042         return (int)(-((int)a));
6043     }
6044 
6045     @Test(dataProvider = "intUnaryOpProvider")
6046     static void NEGInt64VectorTests(IntFunction<int[]> fa) {
6047         int[] a = fa.apply(SPECIES.length());
6048         int[] r = fr.apply(SPECIES.length());
6049 
6050         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6051             for (int i = 0; i < a.length; i += SPECIES.length()) {
6052                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6053                 av.lanewise(VectorOperators.NEG).intoArray(r, i);
6054             }
6055         }
6056 
6057         assertArraysEquals(r, a, Int64VectorTests::NEG);
6058     }
6059 
6060     @Test(dataProvider = "intUnaryOpProvider")
6061     static void negInt64VectorTests(IntFunction<int[]> fa) {
6062         int[] a = fa.apply(SPECIES.length());
6063         int[] r = fr.apply(SPECIES.length());
6064 
6065         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6066             for (int i = 0; i < a.length; i += SPECIES.length()) {
6067                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6068                 av.neg().intoArray(r, i);
6069             }
6070         }
6071 
6072         assertArraysEquals(r, a, Int64VectorTests::neg);
6073     }
6074 
6075     @Test(dataProvider = "intUnaryOpMaskProvider")
6076     static void NEGMaskedInt64VectorTests(IntFunction<int[]> fa,
6077                                                 IntFunction<boolean[]> fm) {
6078         int[] a = fa.apply(SPECIES.length());
6079         int[] r = fr.apply(SPECIES.length());
6080         boolean[] mask = fm.apply(SPECIES.length());
6081         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6082 
6083         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6084             for (int i = 0; i < a.length; i += SPECIES.length()) {
6085                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6086                 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
6087             }
6088         }
6089 
6090         assertArraysEquals(r, a, mask, Int64VectorTests::NEG);
6091     }
6092 
6093     static int ABS(int a) {
6094         return (int)(Math.abs((int)a));
6095     }
6096 
6097     static int abs(int a) {
6098         return (int)(Math.abs((int)a));
6099     }
6100 
6101     @Test(dataProvider = "intUnaryOpProvider")
6102     static void ABSInt64VectorTests(IntFunction<int[]> fa) {
6103         int[] a = fa.apply(SPECIES.length());
6104         int[] r = fr.apply(SPECIES.length());
6105 
6106         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6107             for (int i = 0; i < a.length; i += SPECIES.length()) {
6108                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6109                 av.lanewise(VectorOperators.ABS).intoArray(r, i);
6110             }
6111         }
6112 
6113         assertArraysEquals(r, a, Int64VectorTests::ABS);
6114     }
6115 
6116     @Test(dataProvider = "intUnaryOpProvider")
6117     static void absInt64VectorTests(IntFunction<int[]> fa) {
6118         int[] a = fa.apply(SPECIES.length());
6119         int[] r = fr.apply(SPECIES.length());
6120 
6121         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6122             for (int i = 0; i < a.length; i += SPECIES.length()) {
6123                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6124                 av.abs().intoArray(r, i);
6125             }
6126         }
6127 
6128         assertArraysEquals(r, a, Int64VectorTests::abs);
6129     }
6130 
6131     @Test(dataProvider = "intUnaryOpMaskProvider")
6132     static void ABSMaskedInt64VectorTests(IntFunction<int[]> fa,
6133                                                 IntFunction<boolean[]> fm) {
6134         int[] a = fa.apply(SPECIES.length());
6135         int[] r = fr.apply(SPECIES.length());
6136         boolean[] mask = fm.apply(SPECIES.length());
6137         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6138 
6139         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6140             for (int i = 0; i < a.length; i += SPECIES.length()) {
6141                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6142                 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
6143             }
6144         }
6145 
6146         assertArraysEquals(r, a, mask, Int64VectorTests::ABS);
6147     }
6148 
6149     static int NOT(int a) {
6150         return (int)(~((int)a));
6151     }
6152 
6153     static int not(int a) {
6154         return (int)(~((int)a));
6155     }
6156 
6157     @Test(dataProvider = "intUnaryOpProvider")
6158     static void NOTInt64VectorTests(IntFunction<int[]> fa) {
6159         int[] a = fa.apply(SPECIES.length());
6160         int[] r = fr.apply(SPECIES.length());
6161 
6162         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6163             for (int i = 0; i < a.length; i += SPECIES.length()) {
6164                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6165                 av.lanewise(VectorOperators.NOT).intoArray(r, i);
6166             }
6167         }
6168 
6169         assertArraysEquals(r, a, Int64VectorTests::NOT);
6170     }
6171 
6172     @Test(dataProvider = "intUnaryOpProvider")
6173     static void notInt64VectorTests(IntFunction<int[]> fa) {
6174         int[] a = fa.apply(SPECIES.length());
6175         int[] r = fr.apply(SPECIES.length());
6176 
6177         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6178             for (int i = 0; i < a.length; i += SPECIES.length()) {
6179                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6180                 av.not().intoArray(r, i);
6181             }
6182         }
6183 
6184         assertArraysEquals(r, a, Int64VectorTests::not);
6185     }
6186 
6187     @Test(dataProvider = "intUnaryOpMaskProvider")
6188     static void NOTMaskedInt64VectorTests(IntFunction<int[]> fa,
6189                                                 IntFunction<boolean[]> fm) {
6190         int[] a = fa.apply(SPECIES.length());
6191         int[] r = fr.apply(SPECIES.length());
6192         boolean[] mask = fm.apply(SPECIES.length());
6193         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6194 
6195         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6196             for (int i = 0; i < a.length; i += SPECIES.length()) {
6197                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6198                 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
6199             }
6200         }
6201 
6202         assertArraysEquals(r, a, mask, Int64VectorTests::NOT);
6203     }
6204 
6205     static int ZOMO(int a) {
6206         return (int)((a==0?0:-1));
6207     }
6208 
6209     @Test(dataProvider = "intUnaryOpProvider")
6210     static void ZOMOInt64VectorTests(IntFunction<int[]> fa) {
6211         int[] a = fa.apply(SPECIES.length());
6212         int[] r = fr.apply(SPECIES.length());
6213 
6214         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6215             for (int i = 0; i < a.length; i += SPECIES.length()) {
6216                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6217                 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
6218             }
6219         }
6220 
6221         assertArraysEquals(r, a, Int64VectorTests::ZOMO);
6222     }
6223 
6224     @Test(dataProvider = "intUnaryOpMaskProvider")
6225     static void ZOMOMaskedInt64VectorTests(IntFunction<int[]> fa,
6226                                                 IntFunction<boolean[]> fm) {
6227         int[] a = fa.apply(SPECIES.length());
6228         int[] r = fr.apply(SPECIES.length());
6229         boolean[] mask = fm.apply(SPECIES.length());
6230         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6231 
6232         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6233             for (int i = 0; i < a.length; i += SPECIES.length()) {
6234                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6235                 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
6236             }
6237         }
6238 
6239         assertArraysEquals(r, a, mask, Int64VectorTests::ZOMO);
6240     }
6241 
6242     static int BIT_COUNT(int a) {
6243         return (int)(Integer.bitCount(a));
6244     }
6245 
6246     @Test(dataProvider = "intUnaryOpProvider")
6247     static void BIT_COUNTInt64VectorTests(IntFunction<int[]> fa) {
6248         int[] a = fa.apply(SPECIES.length());
6249         int[] r = fr.apply(SPECIES.length());
6250 
6251         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6252             for (int i = 0; i < a.length; i += SPECIES.length()) {
6253                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6254                 av.lanewise(VectorOperators.BIT_COUNT).intoArray(r, i);
6255             }
6256         }
6257 
6258         assertArraysEquals(r, a, Int64VectorTests::BIT_COUNT);
6259     }
6260 
6261     @Test(dataProvider = "intUnaryOpMaskProvider")
6262     static void BIT_COUNTMaskedInt64VectorTests(IntFunction<int[]> fa,
6263                                                 IntFunction<boolean[]> fm) {
6264         int[] a = fa.apply(SPECIES.length());
6265         int[] r = fr.apply(SPECIES.length());
6266         boolean[] mask = fm.apply(SPECIES.length());
6267         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6268 
6269         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6270             for (int i = 0; i < a.length; i += SPECIES.length()) {
6271                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6272                 av.lanewise(VectorOperators.BIT_COUNT, vmask).intoArray(r, i);
6273             }
6274         }
6275 
6276         assertArraysEquals(r, a, mask, Int64VectorTests::BIT_COUNT);
6277     }
6278 
6279     static int TRAILING_ZEROS_COUNT(int a) {
6280         return (int)(TRAILING_ZEROS_COUNT_scalar(a));
6281     }
6282 
6283     @Test(dataProvider = "intUnaryOpProvider")
6284     static void TRAILING_ZEROS_COUNTInt64VectorTests(IntFunction<int[]> fa) {
6285         int[] a = fa.apply(SPECIES.length());
6286         int[] r = fr.apply(SPECIES.length());
6287 
6288         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6289             for (int i = 0; i < a.length; i += SPECIES.length()) {
6290                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6291                 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT).intoArray(r, i);
6292             }
6293         }
6294 
6295         assertArraysEquals(r, a, Int64VectorTests::TRAILING_ZEROS_COUNT);
6296     }
6297 
6298     @Test(dataProvider = "intUnaryOpMaskProvider")
6299     static void TRAILING_ZEROS_COUNTMaskedInt64VectorTests(IntFunction<int[]> fa,
6300                                                 IntFunction<boolean[]> fm) {
6301         int[] a = fa.apply(SPECIES.length());
6302         int[] r = fr.apply(SPECIES.length());
6303         boolean[] mask = fm.apply(SPECIES.length());
6304         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6305 
6306         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6307             for (int i = 0; i < a.length; i += SPECIES.length()) {
6308                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6309                 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT, vmask).intoArray(r, i);
6310             }
6311         }
6312 
6313         assertArraysEquals(r, a, mask, Int64VectorTests::TRAILING_ZEROS_COUNT);
6314     }
6315 
6316     static int LEADING_ZEROS_COUNT(int a) {
6317         return (int)(LEADING_ZEROS_COUNT_scalar(a));
6318     }
6319 
6320     @Test(dataProvider = "intUnaryOpProvider")
6321     static void LEADING_ZEROS_COUNTInt64VectorTests(IntFunction<int[]> fa) {
6322         int[] a = fa.apply(SPECIES.length());
6323         int[] r = fr.apply(SPECIES.length());
6324 
6325         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6326             for (int i = 0; i < a.length; i += SPECIES.length()) {
6327                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6328                 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT).intoArray(r, i);
6329             }
6330         }
6331 
6332         assertArraysEquals(r, a, Int64VectorTests::LEADING_ZEROS_COUNT);
6333     }
6334 
6335     @Test(dataProvider = "intUnaryOpMaskProvider")
6336     static void LEADING_ZEROS_COUNTMaskedInt64VectorTests(IntFunction<int[]> fa,
6337                                                 IntFunction<boolean[]> fm) {
6338         int[] a = fa.apply(SPECIES.length());
6339         int[] r = fr.apply(SPECIES.length());
6340         boolean[] mask = fm.apply(SPECIES.length());
6341         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6342 
6343         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6344             for (int i = 0; i < a.length; i += SPECIES.length()) {
6345                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6346                 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT, vmask).intoArray(r, i);
6347             }
6348         }
6349 
6350         assertArraysEquals(r, a, mask, Int64VectorTests::LEADING_ZEROS_COUNT);
6351     }
6352 
6353     static int REVERSE(int a) {
6354         return (int)(REVERSE_scalar(a));
6355     }
6356 
6357     @Test(dataProvider = "intUnaryOpProvider")
6358     static void REVERSEInt64VectorTests(IntFunction<int[]> fa) {
6359         int[] a = fa.apply(SPECIES.length());
6360         int[] r = fr.apply(SPECIES.length());
6361 
6362         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6363             for (int i = 0; i < a.length; i += SPECIES.length()) {
6364                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6365                 av.lanewise(VectorOperators.REVERSE).intoArray(r, i);
6366             }
6367         }
6368 
6369         assertArraysEquals(r, a, Int64VectorTests::REVERSE);
6370     }
6371 
6372     @Test(dataProvider = "intUnaryOpMaskProvider")
6373     static void REVERSEMaskedInt64VectorTests(IntFunction<int[]> fa,
6374                                                 IntFunction<boolean[]> fm) {
6375         int[] a = fa.apply(SPECIES.length());
6376         int[] r = fr.apply(SPECIES.length());
6377         boolean[] mask = fm.apply(SPECIES.length());
6378         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6379 
6380         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6381             for (int i = 0; i < a.length; i += SPECIES.length()) {
6382                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6383                 av.lanewise(VectorOperators.REVERSE, vmask).intoArray(r, i);
6384             }
6385         }
6386 
6387         assertArraysEquals(r, a, mask, Int64VectorTests::REVERSE);
6388     }
6389 
6390     static int REVERSE_BYTES(int a) {
6391         return (int)(Integer.reverseBytes(a));
6392     }
6393 
6394     @Test(dataProvider = "intUnaryOpProvider")
6395     static void REVERSE_BYTESInt64VectorTests(IntFunction<int[]> fa) {
6396         int[] a = fa.apply(SPECIES.length());
6397         int[] r = fr.apply(SPECIES.length());
6398 
6399         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6400             for (int i = 0; i < a.length; i += SPECIES.length()) {
6401                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6402                 av.lanewise(VectorOperators.REVERSE_BYTES).intoArray(r, i);
6403             }
6404         }
6405 
6406         assertArraysEquals(r, a, Int64VectorTests::REVERSE_BYTES);
6407     }
6408 
6409     @Test(dataProvider = "intUnaryOpMaskProvider")
6410     static void REVERSE_BYTESMaskedInt64VectorTests(IntFunction<int[]> fa,
6411                                                 IntFunction<boolean[]> fm) {
6412         int[] a = fa.apply(SPECIES.length());
6413         int[] r = fr.apply(SPECIES.length());
6414         boolean[] mask = fm.apply(SPECIES.length());
6415         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6416 
6417         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6418             for (int i = 0; i < a.length; i += SPECIES.length()) {
6419                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6420                 av.lanewise(VectorOperators.REVERSE_BYTES, vmask).intoArray(r, i);
6421             }
6422         }
6423 
6424         assertArraysEquals(r, a, mask, Int64VectorTests::REVERSE_BYTES);
6425     }
6426 
6427     @Test(dataProvider = "intCompareOpProvider")
6428     static void ltInt64VectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
6429         int[] a = fa.apply(SPECIES.length());
6430         int[] b = fb.apply(SPECIES.length());
6431 
6432         for (int i = 0; i < a.length; i += SPECIES.length()) {
6433             IntVector av = IntVector.fromArray(SPECIES, a, i);
6434             VectorMask<Integer> mv = av.lt(b[i]);
6435 
6436             // Check results as part of computation.
6437             for (int j = 0; j < SPECIES.length(); j++) {
6438                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
6439             }
6440         }
6441     }
6442 
6443     @Test(dataProvider = "intCompareOpProvider")
6444     static void eqInt64VectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
6445         int[] a = fa.apply(SPECIES.length());
6446         int[] b = fb.apply(SPECIES.length());
6447 
6448         for (int i = 0; i < a.length; i += SPECIES.length()) {
6449             IntVector av = IntVector.fromArray(SPECIES, a, i);
6450             VectorMask<Integer> mv = av.eq(b[i]);
6451 
6452             // Check results as part of computation.
6453             for (int j = 0; j < SPECIES.length(); j++) {
6454                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
6455             }
6456         }
6457     }
6458 
6459     @Test(dataProvider = "intUnaryOpProvider")
6460     static void toIntArrayInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6461         int[] a = fa.apply(SPECIES.length());
6462 
6463         for (int i = 0; i < a.length; i += SPECIES.length()) {
6464             IntVector av = IntVector.fromArray(SPECIES, a, i);
6465             int[] r = av.toIntArray();
6466             assertArraysEquals(r, a, i);
6467         }
6468     }
6469 
6470     @Test(dataProvider = "intUnaryOpProvider")
6471     static void toLongArrayInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6472         int[] a = fa.apply(SPECIES.length());
6473 
6474         for (int i = 0; i < a.length; i += SPECIES.length()) {
6475             IntVector av = IntVector.fromArray(SPECIES, a, i);
6476             long[] r = av.toLongArray();
6477             assertArraysEquals(r, a, i);
6478         }
6479     }
6480 
6481     @Test(dataProvider = "intUnaryOpProvider")
6482     static void toDoubleArrayInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6483         int[] a = fa.apply(SPECIES.length());
6484 
6485         for (int i = 0; i < a.length; i += SPECIES.length()) {
6486             IntVector av = IntVector.fromArray(SPECIES, a, i);
6487             double[] r = av.toDoubleArray();
6488             assertArraysEquals(r, a, i);
6489         }
6490     }
6491 
6492     @Test(dataProvider = "intUnaryOpProvider")
6493     static void toStringInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6494         int[] a = fa.apply(SPECIES.length());
6495 
6496         for (int i = 0; i < a.length; i += SPECIES.length()) {
6497             IntVector av = IntVector.fromArray(SPECIES, a, i);
6498             String str = av.toString();
6499 
6500             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6501             Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
6502         }
6503     }
6504 
6505     @Test(dataProvider = "intUnaryOpProvider")
6506     static void hashCodeInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6507         int[] a = fa.apply(SPECIES.length());
6508 
6509         for (int i = 0; i < a.length; i += SPECIES.length()) {
6510             IntVector av = IntVector.fromArray(SPECIES, a, i);
6511             int hash = av.hashCode();
6512 
6513             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6514             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6515             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6516         }
6517     }
6518 
6519 
6520     static long ADDReduceLong(int[] a, int idx) {
6521         int res = 0;
6522         for (int i = idx; i < (idx + SPECIES.length()); i++) {
6523             res += a[i];
6524         }
6525 
6526         return (long)res;
6527     }
6528 
6529     static long ADDReduceAllLong(int[] a) {
6530         long res = 0;
6531         for (int i = 0; i < a.length; i += SPECIES.length()) {
6532             res += ADDReduceLong(a, i);
6533         }
6534 
6535         return res;
6536     }
6537 
6538     @Test(dataProvider = "intUnaryOpProvider")
6539     static void ADDReduceLongInt64VectorTests(IntFunction<int[]> fa) {
6540         int[] a = fa.apply(SPECIES.length());
6541         long[] r = lfr.apply(SPECIES.length());
6542         long ra = 0;
6543 
6544         for (int i = 0; i < a.length; i += SPECIES.length()) {
6545             IntVector av = IntVector.fromArray(SPECIES, a, i);
6546             r[i] = av.reduceLanesToLong(VectorOperators.ADD);
6547         }
6548 
6549         ra = 0;
6550         for (int i = 0; i < a.length; i ++) {
6551             ra += r[i];
6552         }
6553 
6554         assertReductionLongArraysEquals(r, ra, a,
6555                 Int64VectorTests::ADDReduceLong, Int64VectorTests::ADDReduceAllLong);
6556     }
6557 
6558     static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) {
6559         int res = 0;
6560         for (int i = idx; i < (idx + SPECIES.length()); i++) {
6561             if(mask[i % SPECIES.length()])
6562                 res += a[i];
6563         }
6564 
6565         return (long)res;
6566     }
6567 
6568     static long ADDReduceAllLongMasked(int[] a, boolean[] mask) {
6569         long res = 0;
6570         for (int i = 0; i < a.length; i += SPECIES.length()) {
6571             res += ADDReduceLongMasked(a, i, mask);
6572         }
6573 
6574         return res;
6575     }
6576 
6577     @Test(dataProvider = "intUnaryOpMaskProvider")
6578     static void ADDReduceLongInt64VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
6579         int[] a = fa.apply(SPECIES.length());
6580         long[] r = lfr.apply(SPECIES.length());
6581         boolean[] mask = fm.apply(SPECIES.length());
6582         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6583         long ra = 0;
6584 
6585         for (int i = 0; i < a.length; i += SPECIES.length()) {
6586             IntVector av = IntVector.fromArray(SPECIES, a, i);
6587             r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
6588         }
6589 
6590         ra = 0;
6591         for (int i = 0; i < a.length; i ++) {
6592             ra += r[i];
6593         }
6594 
6595         assertReductionLongArraysEqualsMasked(r, ra, a, mask,
6596                 Int64VectorTests::ADDReduceLongMasked, Int64VectorTests::ADDReduceAllLongMasked);
6597     }
6598 
6599     @Test(dataProvider = "intUnaryOpProvider")
6600     static void BroadcastLongInt64VectorTestsSmokeTest(IntFunction<int[]> fa) {
6601         int[] a = fa.apply(SPECIES.length());
6602         int[] r = new int[a.length];
6603 
6604         for (int i = 0; i < a.length; i += SPECIES.length()) {
6605             IntVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
6606         }
6607         assertBroadcastArraysEquals(r, a);
6608     }
6609 
6610     @Test(dataProvider = "intBinaryOpMaskProvider")
6611     static void blendInt64VectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
6612                                           IntFunction<boolean[]> fm) {
6613         int[] a = fa.apply(SPECIES.length());
6614         int[] b = fb.apply(SPECIES.length());
6615         int[] r = fr.apply(SPECIES.length());
6616         boolean[] mask = fm.apply(SPECIES.length());
6617         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6618 
6619         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6620             for (int i = 0; i < a.length; i += SPECIES.length()) {
6621                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6622                 av.blend((long)b[i], vmask).intoArray(r, i);
6623             }
6624         }
6625         assertBroadcastLongArraysEquals(r, a, b, mask, Int64VectorTests::blend);
6626     }
6627 
6628 
6629     @Test(dataProvider = "intUnaryOpShuffleProvider")
6630     static void SelectFromInt64VectorTests(IntFunction<int[]> fa,
6631                                            BiFunction<Integer,Integer,int[]> fs) {
6632         int[] a = fa.apply(SPECIES.length());
6633         int[] order = fs.apply(a.length, SPECIES.length());
6634         int[] r = fr.apply(SPECIES.length());
6635 
6636         for (int i = 0; i < a.length; i += SPECIES.length()) {
6637             IntVector av = IntVector.fromArray(SPECIES, a, i);
6638             IntVector bv = IntVector.fromArray(SPECIES, order, i);
6639             bv.selectFrom(av).intoArray(r, i);
6640         }
6641 
6642         assertSelectFromArraysEquals(r, a, order, SPECIES.length());
6643     }
6644 
6645     @Test(dataProvider = "intSelectFromTwoVectorOpProvider")
6646     static void SelectFromTwoVectorInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
6647         int[] a = fa.apply(SPECIES.length());
6648         int[] b = fb.apply(SPECIES.length());
6649         int[] idx = fc.apply(SPECIES.length());
6650         int[] r = fr.apply(SPECIES.length());
6651 
6652         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6653             for (int i = 0; i < idx.length; i += SPECIES.length()) {
6654                 IntVector av = IntVector.fromArray(SPECIES, a, i);
6655                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
6656                 IntVector idxv = IntVector.fromArray(SPECIES, idx, i);
6657                 idxv.selectFrom(av, bv).intoArray(r, i);
6658             }
6659         }
6660         assertSelectFromTwoVectorEquals(r, idx, a, b, SPECIES.length());
6661     }
6662 
6663     @Test(dataProvider = "intUnaryOpShuffleMaskProvider")
6664     static void SelectFromInt64VectorTestsMaskedSmokeTest(IntFunction<int[]> fa,
6665                                                            BiFunction<Integer,Integer,int[]> fs,
6666                                                            IntFunction<boolean[]> fm) {
6667         int[] a = fa.apply(SPECIES.length());
6668         int[] order = fs.apply(a.length, SPECIES.length());
6669         int[] r = fr.apply(SPECIES.length());
6670         boolean[] mask = fm.apply(SPECIES.length());
6671         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6672 
6673         for (int i = 0; i < a.length; i += SPECIES.length()) {
6674             IntVector av = IntVector.fromArray(SPECIES, a, i);
6675             IntVector bv = IntVector.fromArray(SPECIES, order, i);
6676             bv.selectFrom(av, vmask).intoArray(r, i);
6677         }
6678 
6679         assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
6680     }
6681 
6682     @Test(dataProvider = "shuffleProvider")
6683     static void shuffleMiscellaneousInt64VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
6684         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6685 
6686         for (int i = 0; i < a.length; i += SPECIES.length()) {
6687             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
6688             int hash = shuffle.hashCode();
6689             int length = shuffle.length();
6690 
6691             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6692             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6693             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6694             Assert.assertEquals(length, SPECIES.length());
6695         }
6696     }
6697 
6698     @Test(dataProvider = "shuffleProvider")
6699     static void shuffleToStringInt64VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
6700         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6701 
6702         for (int i = 0; i < a.length; i += SPECIES.length()) {
6703             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
6704             String str = shuffle.toString();
6705 
6706             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6707             Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
6708                 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
6709         }
6710     }
6711 
6712     @Test(dataProvider = "shuffleCompareOpProvider")
6713     static void shuffleEqualsInt64VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
6714         int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6715         int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6716 
6717         for (int i = 0; i < a.length; i += SPECIES.length()) {
6718             var av = VectorShuffle.fromArray(SPECIES, a, i);
6719             var bv = VectorShuffle.fromArray(SPECIES, b, i);
6720             boolean eq = av.equals(bv);
6721             int to = i + SPECIES.length();
6722             Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
6723         }
6724     }
6725 
6726     @Test(dataProvider = "maskCompareOpProvider")
6727     static void maskEqualsInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6728         boolean[] a = fa.apply(SPECIES.length());
6729         boolean[] b = fb.apply(SPECIES.length());
6730 
6731         for (int i = 0; i < a.length; i += SPECIES.length()) {
6732             var av = SPECIES.loadMask(a, i);
6733             var bv = SPECIES.loadMask(b, i);
6734             boolean equals = av.equals(bv);
6735             int to = i + SPECIES.length();
6736             Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
6737         }
6738     }
6739 
6740     static boolean band(boolean a, boolean b) {
6741         return a & b;
6742     }
6743 
6744     @Test(dataProvider = "maskCompareOpProvider")
6745     static void maskAndInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6746         boolean[] a = fa.apply(SPECIES.length());
6747         boolean[] b = fb.apply(SPECIES.length());
6748         boolean[] r = new boolean[a.length];
6749 
6750         for (int i = 0; i < a.length; i += SPECIES.length()) {
6751             var av = SPECIES.loadMask(a, i);
6752             var bv = SPECIES.loadMask(b, i);
6753             var cv = av.and(bv);
6754             cv.intoArray(r, i);
6755         }
6756         assertArraysEquals(r, a, b, Int64VectorTests::band);
6757     }
6758 
6759     static boolean bor(boolean a, boolean b) {
6760         return a | b;
6761     }
6762 
6763     @Test(dataProvider = "maskCompareOpProvider")
6764     static void maskOrInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6765         boolean[] a = fa.apply(SPECIES.length());
6766         boolean[] b = fb.apply(SPECIES.length());
6767         boolean[] r = new boolean[a.length];
6768 
6769         for (int i = 0; i < a.length; i += SPECIES.length()) {
6770             var av = SPECIES.loadMask(a, i);
6771             var bv = SPECIES.loadMask(b, i);
6772             var cv = av.or(bv);
6773             cv.intoArray(r, i);
6774         }
6775         assertArraysEquals(r, a, b, Int64VectorTests::bor);
6776     }
6777 
6778     static boolean bxor(boolean a, boolean b) {
6779         return a != b;
6780     }
6781 
6782     @Test(dataProvider = "maskCompareOpProvider")
6783     static void maskXorInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6784         boolean[] a = fa.apply(SPECIES.length());
6785         boolean[] b = fb.apply(SPECIES.length());
6786         boolean[] r = new boolean[a.length];
6787 
6788         for (int i = 0; i < a.length; i += SPECIES.length()) {
6789             var av = SPECIES.loadMask(a, i);
6790             var bv = SPECIES.loadMask(b, i);
6791             var cv = av.xor(bv);
6792             cv.intoArray(r, i);
6793         }
6794         assertArraysEquals(r, a, b, Int64VectorTests::bxor);
6795     }
6796 
6797     static boolean bandNot(boolean a, boolean b) {
6798         return a & !b;
6799     }
6800 
6801     @Test(dataProvider = "maskCompareOpProvider")
6802     static void maskAndNotInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6803         boolean[] a = fa.apply(SPECIES.length());
6804         boolean[] b = fb.apply(SPECIES.length());
6805         boolean[] r = new boolean[a.length];
6806 
6807         for (int i = 0; i < a.length; i += SPECIES.length()) {
6808             var av = SPECIES.loadMask(a, i);
6809             var bv = SPECIES.loadMask(b, i);
6810             var cv = av.andNot(bv);
6811             cv.intoArray(r, i);
6812         }
6813         assertArraysEquals(r, a, b, Int64VectorTests::bandNot);
6814     }
6815 
6816     static boolean beq(boolean a, boolean b) {
6817         return (a == b);
6818     }
6819 
6820     @Test(dataProvider = "maskCompareOpProvider")
6821     static void maskEqInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6822         boolean[] a = fa.apply(SPECIES.length());
6823         boolean[] b = fb.apply(SPECIES.length());
6824         boolean[] r = new boolean[a.length];
6825 
6826         for (int i = 0; i < a.length; i += SPECIES.length()) {
6827             var av = SPECIES.loadMask(a, i);
6828             var bv = SPECIES.loadMask(b, i);
6829             var cv = av.eq(bv);
6830             cv.intoArray(r, i);
6831         }
6832         assertArraysEquals(r, a, b, Int64VectorTests::beq);
6833     }
6834 
6835     @Test(dataProvider = "maskProvider")
6836     static void maskHashCodeInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6837         boolean[] a = fa.apply(SPECIES.length());
6838 
6839         for (int i = 0; i < a.length; i += SPECIES.length()) {
6840             var vmask = SPECIES.loadMask(a, i);
6841             int hash = vmask.hashCode();
6842 
6843             boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6844             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6845             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6846         }
6847     }
6848 
6849     static int maskTrueCount(boolean[] a, int idx) {
6850         int trueCount = 0;
6851         for (int i = idx; i < idx + SPECIES.length(); i++) {
6852             trueCount += a[i] ? 1 : 0;
6853         }
6854         return trueCount;
6855     }
6856 
6857     @Test(dataProvider = "maskProvider")
6858     static void maskTrueCountInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6859         boolean[] a = fa.apply(SPECIES.length());
6860         int[] r = new int[a.length];
6861 
6862         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6863             for (int i = 0; i < a.length; i += SPECIES.length()) {
6864                 var vmask = SPECIES.loadMask(a, i);
6865                 r[i] = vmask.trueCount();
6866             }
6867         }
6868 
6869         assertMaskReductionArraysEquals(r, a, Int64VectorTests::maskTrueCount);
6870     }
6871 
6872     static int maskLastTrue(boolean[] a, int idx) {
6873         int i = idx + SPECIES.length() - 1;
6874         for (; i >= idx; i--) {
6875             if (a[i]) {
6876                 break;
6877             }
6878         }
6879         return i - idx;
6880     }
6881 
6882     @Test(dataProvider = "maskProvider")
6883     static void maskLastTrueInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6884         boolean[] a = fa.apply(SPECIES.length());
6885         int[] r = new int[a.length];
6886 
6887         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6888             for (int i = 0; i < a.length; i += SPECIES.length()) {
6889                 var vmask = SPECIES.loadMask(a, i);
6890                 r[i] = vmask.lastTrue();
6891             }
6892         }
6893 
6894         assertMaskReductionArraysEquals(r, a, Int64VectorTests::maskLastTrue);
6895     }
6896 
6897     static int maskFirstTrue(boolean[] a, int idx) {
6898         int i = idx;
6899         for (; i < idx + SPECIES.length(); i++) {
6900             if (a[i]) {
6901                 break;
6902             }
6903         }
6904         return i - idx;
6905     }
6906 
6907     @Test(dataProvider = "maskProvider")
6908     static void maskFirstTrueInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6909         boolean[] a = fa.apply(SPECIES.length());
6910         int[] r = new int[a.length];
6911 
6912         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6913             for (int i = 0; i < a.length; i += SPECIES.length()) {
6914                 var vmask = SPECIES.loadMask(a, i);
6915                 r[i] = vmask.firstTrue();
6916             }
6917         }
6918 
6919         assertMaskReductionArraysEquals(r, a, Int64VectorTests::maskFirstTrue);
6920     }
6921 
6922     @Test(dataProvider = "maskProvider")
6923     static void maskCompressInt64VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6924         int trueCount = 0;
6925         boolean[] a = fa.apply(SPECIES.length());
6926 
6927         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6928             for (int i = 0; i < a.length; i += SPECIES.length()) {
6929                 var vmask = SPECIES.loadMask(a, i);
6930                 trueCount = vmask.trueCount();
6931                 var rmask = vmask.compress();
6932                 for (int j = 0; j < SPECIES.length(); j++)  {
6933                     Assert.assertEquals(rmask.laneIsSet(j), j < trueCount);
6934                 }
6935             }
6936         }
6937     }
6938 
6939     @DataProvider
6940     public static Object[][] longMaskProvider() {
6941         return new Object[][]{
6942                 {0xFFFFFFFFFFFFFFFFL},
6943                 {0x0000000000000000L},
6944                 {0x5555555555555555L},
6945                 {0x0123456789abcdefL},
6946         };
6947     }
6948 
6949     @Test(dataProvider = "longMaskProvider")
6950     static void maskFromToLongInt64VectorTestsSmokeTest(long inputLong) {
6951         var vmask = VectorMask.fromLong(SPECIES, inputLong);
6952         long outputLong = vmask.toLong();
6953         Assert.assertEquals(outputLong, (inputLong & (((0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()))))));
6954     }
6955 
6956     @DataProvider
6957     public static Object[][] offsetProvider() {
6958         return new Object[][]{
6959                 {0},
6960                 {-1},
6961                 {+1},
6962                 {+2},
6963                 {-2},
6964         };
6965     }
6966 
6967     @Test(dataProvider = "offsetProvider")
6968     static void indexInRangeInt64VectorTestsSmokeTest(int offset) {
6969         int limit = SPECIES.length() * BUFFER_REPS;
6970         for (int i = 0; i < limit; i += SPECIES.length()) {
6971             var actualMask = SPECIES.indexInRange(i + offset, limit);
6972             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
6973             assert(actualMask.equals(expectedMask));
6974             for (int j = 0; j < SPECIES.length(); j++)  {
6975                 int index = i + j + offset;
6976                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
6977             }
6978         }
6979     }
6980 
6981     @Test(dataProvider = "offsetProvider")
6982     static void indexInRangeLongInt64VectorTestsSmokeTest(int offset) {
6983         long limit = SPECIES.length() * BUFFER_REPS;
6984         for (long i = 0; i < limit; i += SPECIES.length()) {
6985             var actualMask = SPECIES.indexInRange(i + offset, limit);
6986             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
6987             assert(actualMask.equals(expectedMask));
6988             for (int j = 0; j < SPECIES.length(); j++)  {
6989                 long index = i + j + offset;
6990                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
6991             }
6992         }
6993     }
6994 
6995     @DataProvider
6996     public static Object[][] lengthProvider() {
6997         return new Object[][]{
6998                 {0},
6999                 {1},
7000                 {32},
7001                 {37},
7002                 {1024},
7003                 {1024+1},
7004                 {1024+5},
7005         };
7006     }
7007 
7008     @Test(dataProvider = "lengthProvider")
7009     static void loopBoundInt64VectorTestsSmokeTest(int length) {
7010         int actualLoopBound = SPECIES.loopBound(length);
7011         int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
7012         Assert.assertEquals(actualLoopBound, expectedLoopBound);
7013     }
7014 
7015     @Test(dataProvider = "lengthProvider")
7016     static void loopBoundLongInt64VectorTestsSmokeTest(int _length) {
7017         long length = _length;
7018         long actualLoopBound = SPECIES.loopBound(length);
7019         long expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
7020         Assert.assertEquals(actualLoopBound, expectedLoopBound);
7021     }
7022 
7023     @Test
7024     static void ElementSizeInt64VectorTestsSmokeTest() {
7025         IntVector av = IntVector.zero(SPECIES);
7026         int elsize = av.elementSize();
7027         Assert.assertEquals(elsize, Integer.SIZE);
7028     }
7029 
7030     @Test
7031     static void VectorShapeInt64VectorTestsSmokeTest() {
7032         IntVector av = IntVector.zero(SPECIES);
7033         VectorShape vsh = av.shape();
7034         assert(vsh.equals(VectorShape.S_64_BIT));
7035     }
7036 
7037     @Test
7038     static void ShapeWithLanesInt64VectorTestsSmokeTest() {
7039         IntVector av = IntVector.zero(SPECIES);
7040         VectorShape vsh = av.shape();
7041         VectorSpecies species = vsh.withLanes(int.class);
7042         assert(species.equals(SPECIES));
7043     }
7044 
7045     @Test
7046     static void ElementTypeInt64VectorTestsSmokeTest() {
7047         IntVector av = IntVector.zero(SPECIES);
7048         assert(av.species().elementType() == int.class);
7049     }
7050 
7051     @Test
7052     static void SpeciesElementSizeInt64VectorTestsSmokeTest() {
7053         IntVector av = IntVector.zero(SPECIES);
7054         assert(av.species().elementSize() == Integer.SIZE);
7055     }
7056 
7057     @Test
7058     static void VectorTypeInt64VectorTestsSmokeTest() {
7059         IntVector av = IntVector.zero(SPECIES);
7060         assert(av.species().vectorType() == av.getClass());
7061     }
7062 
7063     @Test
7064     static void WithLanesInt64VectorTestsSmokeTest() {
7065         IntVector av = IntVector.zero(SPECIES);
7066         VectorSpecies species = av.species().withLanes(int.class);
7067         assert(species.equals(SPECIES));
7068     }
7069 
7070     @Test
7071     static void WithShapeInt64VectorTestsSmokeTest() {
7072         IntVector av = IntVector.zero(SPECIES);
7073         VectorShape vsh = av.shape();
7074         VectorSpecies species = av.species().withShape(vsh);
7075         assert(species.equals(SPECIES));
7076     }
7077 
7078     @Test
7079     static void MaskAllTrueInt64VectorTestsSmokeTest() {
7080         for (int ic = 0; ic < INVOC_COUNT; ic++) {
7081           Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
7082         }
7083     }
7084 }
--- EOF ---