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 Short512VectorTests
  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.ShortVector;
  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 Short512VectorTests extends AbstractVectorTest {
  60 
  61     static final VectorSpecies<Short> SPECIES =
  62                 ShortVector.SPECIES_512;
  63 
  64     static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
  65 
  66     static ShortVector bcast_vec = ShortVector.broadcast(SPECIES, (short)10);
  67 
  68 
  69     private static final short CONST_SHIFT = Short.SIZE / 2;
  70 
  71     static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 512);
  72 
  73     static void assertArraysStrictlyEquals(short[] r, short[] 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         short apply(short a);
  83     }
  84 
  85     static void assertArraysEquals(short[] r, short[] 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         short[] apply(short a);
  98     }
  99 
 100     static void assertArraysEquals(short[] r, short[] 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             short[] ref = f.apply(a[i]);
 109             short[] 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(short[] r, short[] 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         short apply(short[] a, int idx);
 129     }
 130 
 131     interface FReductionAllOp {
 132         short apply(short[] a);
 133     }
 134 
 135     static void assertReductionArraysEquals(short[] r, short rc, short[] 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         short apply(short[] a, int idx, boolean[] mask);
 151     }
 152 
 153     interface FReductionAllMaskedOp {
 154         short apply(short[] a, boolean[] mask);
 155     }
 156 
 157     static void assertReductionArraysEqualsMasked(short[] r, short rc, short[] 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(short[] a, int idx);
 173     }
 174 
 175     interface FReductionAllOpLong {
 176         long apply(short[] a);
 177     }
 178 
 179     static void assertReductionLongArraysEquals(long[] r, long rc, short[] 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(short[] a, int idx, boolean[] mask);
 195     }
 196 
 197     interface FReductionAllMaskedOpLong {
 198         long apply(short[] a, boolean[] mask);
 199     }
 200 
 201     static void assertReductionLongArraysEqualsMasked(long[] r, long rc, short[] 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(short[] r, short[] 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(short[] r, short[] 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], (short)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], (short)0, "at index #" + idx);
 280             }
 281         }
 282     }
 283 
 284     static void assertexpandArraysEquals(short[] r, short[] 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], (short)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], (short)0, "at index #" + idx);
 304             }
 305         }
 306     }
 307 
 308     static void assertSelectFromTwoVectorEquals(short[] r, short[] order, short[] a, short[] 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(short[] r, short[] a, short[] 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(short[] r, short[] 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], (short)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], (short)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 358         }
 359     }
 360 
 361     static void assertSelectFromArraysEquals(short[] r, short[] a, short[] 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], (short)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], (short)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 378         }
 379     }
 380 
 381     static void assertBroadcastArraysEquals(short[] r, short[] 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         short apply(short a, short b);
 400     }
 401 
 402     interface FBinMaskOp {
 403         short apply(short a, short 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(short[] rl, short[] rr, short[] a, short[] b, short[] 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(short[] rl, short[] rr, short[] a, short[] b, short[] c, boolean[] mask, FBinOp f) {
 431        assertArraysEqualsAssociative(rl, rr, a, b, c, mask, FBinMaskOp.lift(f));
 432    }
 433 
 434     static void assertArraysEqualsAssociative(short[] rl, short[] rr, short[] a, short[] b, short[] 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(short[] r, short[] a, short[] 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(short[] r, short[] a, short 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(short[] r, short[] a, short[] 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(short[] r, short[] a, short[] b, FBinOp f) {
 491         int i = 0;
 492         try {
 493             for (; i < a.length; i++) {
 494                 Assert.assertEquals(r[i], f.apply(a[i], (short)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
 495             }
 496         } catch (AssertionError e) {
 497             Assert.assertEquals(r[i], f.apply(a[i], (short)((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(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
 503         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 504     }
 505 
 506     static void assertArraysEquals(short[] r, short[] a, short[] 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(short[] r, short[] a, short b, boolean[] mask, FBinOp f) {
 518         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 519     }
 520 
 521     static void assertArraysEquals(short[] r, short[] a, short 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(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
 533         assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 534     }
 535 
 536     static void assertBroadcastArraysEquals(short[] r, short[] a, short[] 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(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
 551         assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 552     }
 553 
 554     static void assertBroadcastLongArraysEquals(short[] r, short[] a, short[] 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], (short)((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], (short)((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(short[] r, short[] a, short[] 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(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
 583         assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 584     }
 585 
 586     static void assertShiftArraysEquals(short[] r, short[] a, short[] 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         short apply(short a);
 602     }
 603 
 604     interface FBinConstMaskOp {
 605         short apply(short 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(short[] r, short[] 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(short[] r, short[] a, boolean[] mask, FBinConstOp f) {
 627         assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
 628     }
 629 
 630     static void assertShiftConstEquals(short[] r, short[] 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         short apply(short a, short b, short c);
 646     }
 647 
 648     interface FTernMaskOp {
 649         short apply(short a, short b, short 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(short[] r, short[] a, short[] b, short[] 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(short[] r, short[] a, short[] b, short[] c, boolean[] mask, FTernOp f) {
 668         assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 669     }
 670 
 671     static void assertArraysEquals(short[] r, short[] a, short[] b, short[] 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(short[] r, short[] a, short[] b, short[] 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(short[] r, short[] a, short[] b, short[] 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(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
 710                                             FTernOp f) {
 711         assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 712     }
 713 
 714     static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] 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(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
 731                                             FTernOp f) {
 732         assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 733     }
 734 
 735     static void assertAltBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] 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(short[] r, short[] a, short[] b, short[] 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(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
 767                                                   FTernOp f) {
 768         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 769     }
 770 
 771     static void assertDoubleBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] 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         short[] apply(short[] a, int ix, int[] b, int iy);
 792     }
 793 
 794     static void assertArraysEquals(short[] r, short[] 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             short[] ref = f.apply(a, i, b, i);
 803             short[] 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         short[] apply(short[] a, int ix, boolean[] mask, int[] b, int iy);
 815     }
 816 
 817     interface FScatterMaskedOp {
 818         short[] apply(short[] r, short[] a, int ix, boolean[] mask, int[] b, int iy);
 819     }
 820 
 821     static void assertArraysEquals(short[] r, short[] 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             short[] ref = f.apply(a, i, mask, b, i);
 830             short[] 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(short[] r, short[] 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             short[] ref = f.apply(r, a, i, mask, b, i);
 851             short[] 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         short[] apply(short[] a, int origin, int idx);
 867     }
 868 
 869     static void assertArraysEquals(short[] r, short[] 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             short[] ref = f.apply(a, origin, i);
 878             short[] 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         short[] apply(short[] a, short[] b, int origin, int idx);
 887     }
 888 
 889     static void assertArraysEquals(short[] r, short[] a, short[] 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             short[] ref = f.apply(a, b, origin, i);
 898             short[] 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         short[] apply(short[] a, short[] b, int origin, boolean[] mask, int idx);
 908     }
 909 
 910     static void assertArraysEquals(short[] r, short[] a, short[] 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             short[] ref = f.apply(a, b, origin, mask, i);
 919             short[] 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         short[] apply(short[] a, short[] b, int origin, int part, int idx);
 929     }
 930 
 931     static void assertArraysEquals(short[] r, short[] a, short[] 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             short[] ref = f.apply(a, b, origin, part, i);
 940             short[] 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         short[] apply(short[] a, short[] b, int origin, int part, boolean[] mask, int idx);
 951     }
 952 
 953     static void assertArraysEquals(short[] r, short[] a, short[] 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             short[] ref = f.apply(a, b, origin, part, mask, i);
 962             short[] 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, short[] 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, short[] 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, short[] 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 short bits(short e) {
1008         return  e;
1009     }
1010 
1011     static final List<IntFunction<short[]>> SHORT_GENERATORS = List.of(
1012             withToString("short[-i * 5]", (int s) -> {
1013                 return fill(s * BUFFER_REPS,
1014                             i -> (short)(-i * 5));
1015             }),
1016             withToString("short[i * 5]", (int s) -> {
1017                 return fill(s * BUFFER_REPS,
1018                             i -> (short)(i * 5));
1019             }),
1020             withToString("short[i + 1]", (int s) -> {
1021                 return fill(s * BUFFER_REPS,
1022                             i -> (((short)(i + 1) == 0) ? 1 : (short)(i + 1)));
1023             }),
1024             withToString("short[cornerCaseValue(i)]", (int s) -> {
1025                 return fill(s * BUFFER_REPS,
1026                             i -> cornerCaseValue(i));
1027             })
1028     );
1029 
1030     static final List<IntFunction<short[]>> SHORT_SATURATING_GENERATORS = List.of(
1031             withToString("short[Short.MIN_VALUE]", (int s) -> {
1032                 return fill(s * BUFFER_REPS,
1033                             i -> (short)(Short.MIN_VALUE));
1034             }),
1035             withToString("short[Short.MAX_VALUE]", (int s) -> {
1036                 return fill(s * BUFFER_REPS,
1037                             i -> (short)(Short.MAX_VALUE));
1038             }),
1039             withToString("short[Short.MAX_VALUE - 100]", (int s) -> {
1040                 return fill(s * BUFFER_REPS,
1041                             i -> (short)(Short.MAX_VALUE - 100));
1042             }),
1043             withToString("short[Short.MIN_VALUE + 100]", (int s) -> {
1044                 return fill(s * BUFFER_REPS,
1045                             i -> (short)(Short.MIN_VALUE + 100));
1046             }),
1047             withToString("short[-i * 5]", (int s) -> {
1048                 return fill(s * BUFFER_REPS,
1049                             i -> (short)(-i * 5));
1050             }),
1051             withToString("short[i * 5]", (int s) -> {
1052                 return fill(s * BUFFER_REPS,
1053                             i -> (short)(i * 5));
1054             })
1055     );
1056 
1057     static final List<IntFunction<short[]>> SHORT_SATURATING_GENERATORS_ASSOC = List.of(
1058             withToString("short[Short.MAX_VALUE]", (int s) -> {
1059                 return fill(s * BUFFER_REPS,
1060                             i -> (short)(Short.MAX_VALUE));
1061             }),
1062             withToString("short[Short.MAX_VALUE - 100]", (int s) -> {
1063                 return fill(s * BUFFER_REPS,
1064                             i -> (short)(Short.MAX_VALUE - 100));
1065             }),
1066             withToString("short[-1]", (int s) -> {
1067                 return fill(s * BUFFER_REPS,
1068                             i -> (short)(-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<short[]>>> SHORT_GENERATOR_PAIRS =
1075         Stream.of(SHORT_GENERATORS.get(0)).
1076                 flatMap(fa -> SHORT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1077                 collect(Collectors.toList());
1078 
1079     static final List<List<IntFunction<short[]>>> SHORT_SATURATING_GENERATOR_PAIRS =
1080         Stream.of(SHORT_GENERATORS.get(0)).
1081                 flatMap(fa -> SHORT_SATURATING_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1082                 collect(Collectors.toList());
1083 
1084     static final List<List<IntFunction<short[]>>> SHORT_SATURATING_GENERATOR_TRIPLETS =
1085             Stream.of(SHORT_GENERATORS.get(1))
1086                     .flatMap(fa -> SHORT_SATURATING_GENERATORS_ASSOC.stream().map(fb -> List.of(fa, fb)))
1087                     .flatMap(pair -> SHORT_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<short[]>>> SHORT_GENERATOR_TRIPLES =
1098         SHORT_GENERATOR_PAIRS.stream().
1099                 flatMap(pair -> SHORT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1100                 collect(Collectors.toList());
1101 
1102     static final List<IntFunction<short[]>> SELECT_FROM_INDEX_GENERATORS = List.of(
1103             withToString("short[0..VECLEN*2)", (int s) -> {
1104                 return fill(s * BUFFER_REPS,
1105                             i -> (short)(RAND.nextInt()));
1106             })
1107     );
1108 
1109     static final List<List<IntFunction<short[]>>> SHORT_GENERATOR_SELECT_FROM_TRIPLES =
1110         SHORT_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[][] shortBinaryOpProvider() {
1116         return SHORT_GENERATOR_PAIRS.stream().map(List::toArray).
1117                 toArray(Object[][]::new);
1118     }
1119 
1120     @DataProvider
1121     public Object[][] shortSaturatingBinaryOpProvider() {
1122         return SHORT_SATURATING_GENERATOR_PAIRS.stream().map(List::toArray).
1123                 toArray(Object[][]::new);
1124     }
1125 
1126     @DataProvider
1127     public Object[][] shortSaturatingBinaryOpAssocProvider() {
1128         return SHORT_SATURATING_GENERATOR_TRIPLETS.stream().map(List::toArray).
1129                 toArray(Object[][]::new);
1130     }
1131 
1132     @DataProvider
1133     public Object[][] shortSaturatingBinaryOpAssocMaskProvider() {
1134         return BOOLEAN_MASK_GENERATORS.stream().
1135                 flatMap(fm -> SHORT_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[][] shortIndexedOpProvider() {
1144         return SHORT_GENERATOR_PAIRS.stream().map(List::toArray).
1145                 toArray(Object[][]::new);
1146     }
1147 
1148     @DataProvider
1149     public Object[][] shortSaturatingBinaryOpMaskProvider() {
1150         return BOOLEAN_MASK_GENERATORS.stream().
1151                 flatMap(fm -> SHORT_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[][] shortSaturatingUnaryOpProvider() {
1159        return SHORT_SATURATING_GENERATORS.stream().
1160                     map(f -> new Object[]{f}).
1161                     toArray(Object[][]::new);
1162    }
1163 
1164    @DataProvider
1165    public Object[][] shortSaturatingUnaryOpMaskProvider() {
1166         return BOOLEAN_MASK_GENERATORS.stream().
1167                 flatMap(fm -> SHORT_SATURATING_GENERATORS.stream().map(fa -> {
1168                     return new Object[] {fa, fm};
1169                 })).
1170                 toArray(Object[][]::new);
1171    }
1172 
1173     @DataProvider
1174     public Object[][] shortBinaryOpMaskProvider() {
1175         return BOOLEAN_MASK_GENERATORS.stream().
1176                 flatMap(fm -> SHORT_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[][] shortTernaryOpProvider() {
1184         return SHORT_GENERATOR_TRIPLES.stream().map(List::toArray).
1185                 toArray(Object[][]::new);
1186     }
1187 
1188     @DataProvider
1189     public Object[][] shortSelectFromTwoVectorOpProvider() {
1190         return SHORT_GENERATOR_SELECT_FROM_TRIPLES.stream().map(List::toArray).
1191                 toArray(Object[][]::new);
1192     }
1193 
1194     @DataProvider
1195     public Object[][] shortTernaryOpMaskProvider() {
1196         return BOOLEAN_MASK_GENERATORS.stream().
1197                 flatMap(fm -> SHORT_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[][] shortUnaryOpProvider() {
1205         return SHORT_GENERATORS.stream().
1206                 map(f -> new Object[]{f}).
1207                 toArray(Object[][]::new);
1208     }
1209 
1210     @DataProvider
1211     public Object[][] shortUnaryOpMaskProvider() {
1212         return BOOLEAN_MASK_GENERATORS.stream().
1213                 flatMap(fm -> SHORT_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[][] shortUnaryOpShuffleProvider() {
1247         return INT_SHUFFLE_GENERATORS.stream().
1248                 flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1249                     return new Object[] {fa, fs};
1250                 })).
1251                 toArray(Object[][]::new);
1252     }
1253 
1254     @DataProvider
1255     public Object[][] shortUnaryOpShuffleMaskProvider() {
1256         return BOOLEAN_MASK_GENERATORS.stream().
1257                 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1258                     flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1259                         return new Object[] {fa, fs, fm};
1260                 }))).
1261                 toArray(Object[][]::new);
1262     }
1263 
1264     static final List<BiFunction<Integer,Integer,short[]>> SHORT_SHUFFLE_GENERATORS = List.of(
1265             withToStringBi("shuffle[random]", (Integer l, Integer m) -> {
1266                 short[] a = new short[l];
1267                 int upper = m;
1268                 for (int i = 0; i < 1; i++) {
1269                     a[i] = (short)RAND.nextInt(upper);
1270                 }
1271                 return a;
1272             })
1273     );
1274 
1275     @DataProvider
1276     public Object[][] shortUnaryOpSelectFromProvider() {
1277         return SHORT_SHUFFLE_GENERATORS.stream().
1278                 flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1279                     return new Object[] {fa, fs};
1280                 })).
1281                 toArray(Object[][]::new);
1282     }
1283 
1284     @DataProvider
1285     public Object[][] shortUnaryOpSelectFromMaskProvider() {
1286         return BOOLEAN_MASK_GENERATORS.stream().
1287                 flatMap(fm -> SHORT_SHUFFLE_GENERATORS.stream().
1288                     flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1289                         return new Object[] {fa, fs, fm};
1290                 }))).
1291                 toArray(Object[][]::new);
1292     }
1293 
1294     static final List<IntFunction<short[]>> SHORT_COMPARE_GENERATORS = List.of(
1295             withToString("short[i]", (int s) -> {
1296                 return fill(s * BUFFER_REPS,
1297                             i -> (short)i);
1298             }),
1299             withToString("short[i - length / 2]", (int s) -> {
1300                 return fill(s * BUFFER_REPS,
1301                             i -> (short)(i - (s * BUFFER_REPS / 2)));
1302             }),
1303             withToString("short[i + 1]", (int s) -> {
1304                 return fill(s * BUFFER_REPS,
1305                             i -> (short)(i + 1));
1306             }),
1307             withToString("short[i - 2]", (int s) -> {
1308                 return fill(s * BUFFER_REPS,
1309                             i -> (short)(i - 2));
1310             }),
1311             withToString("short[zigZag(i)]", (int s) -> {
1312                 return fill(s * BUFFER_REPS,
1313                             i -> i%3 == 0 ? (short)i : (i%3 == 1 ? (short)(i + 1) : (short)(i - 2)));
1314             }),
1315             withToString("short[cornerCaseValue(i)]", (int s) -> {
1316                 return fill(s * BUFFER_REPS,
1317                             i -> cornerCaseValue(i));
1318             })
1319     );
1320 
1321     static final List<List<IntFunction<short[]>>> SHORT_TEST_GENERATOR_ARGS =
1322         SHORT_COMPARE_GENERATORS.stream().
1323                 map(fa -> List.of(fa)).
1324                 collect(Collectors.toList());
1325 
1326     @DataProvider
1327     public Object[][] shortTestOpProvider() {
1328         return SHORT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1329                 toArray(Object[][]::new);
1330     }
1331 
1332     @DataProvider
1333     public Object[][] shortTestOpMaskProvider() {
1334         return BOOLEAN_MASK_GENERATORS.stream().
1335                 flatMap(fm -> SHORT_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1336                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1337                 })).
1338                 toArray(Object[][]::new);
1339     }
1340 
1341     static final List<List<IntFunction<short[]>>> SHORT_COMPARE_GENERATOR_PAIRS =
1342         SHORT_COMPARE_GENERATORS.stream().
1343                 flatMap(fa -> SHORT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1344                 collect(Collectors.toList());
1345 
1346     @DataProvider
1347     public Object[][] shortCompareOpProvider() {
1348         return SHORT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1349                 toArray(Object[][]::new);
1350     }
1351 
1352     @DataProvider
1353     public Object[][] shortCompareOpMaskProvider() {
1354         return BOOLEAN_MASK_GENERATORS.stream().
1355                 flatMap(fm -> SHORT_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1356                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1357                 })).
1358                 toArray(Object[][]::new);
1359     }
1360 
1361     interface ToShortF {
1362         short apply(int i);
1363     }
1364 
1365     static short[] fill(int s , ToShortF f) {
1366         return fill(new short[s], f);
1367     }
1368 
1369     static short[] fill(short[] a, ToShortF f) {
1370         for (int i = 0; i < a.length; i++) {
1371             a[i] = f.apply(i);
1372         }
1373         return a;
1374     }
1375 
1376     static short cornerCaseValue(int i) {
1377         switch(i % 5) {
1378             case 0:
1379                 return Short.MAX_VALUE;
1380             case 1:
1381                 return Short.MIN_VALUE;
1382             case 2:
1383                 return Short.MIN_VALUE;
1384             case 3:
1385                 return Short.MAX_VALUE;
1386             default:
1387                 return (short)0;
1388         }
1389     }
1390 
1391     static final IntFunction<short[]> fr = (vl) -> {
1392         int length = BUFFER_REPS * vl;
1393         return new short[length];
1394     };
1395 
1396     static final IntFunction<boolean[]> fmr = (vl) -> {
1397         int length = BUFFER_REPS * vl;
1398         return new boolean[length];
1399     };
1400 
1401     static final IntFunction<long[]> lfr = (vl) -> {
1402         int length = BUFFER_REPS * vl;
1403         return new long[length];
1404     };
1405 
1406     static void replaceZero(short[] a, short v) {
1407         for (int i = 0; i < a.length; i++) {
1408             if (a[i] == 0) {
1409                 a[i] = v;
1410             }
1411         }
1412     }
1413 
1414     static void replaceZero(short[] a, boolean[] mask, short v) {
1415         for (int i = 0; i < a.length; i++) {
1416             if (mask[i % mask.length] && a[i] == 0) {
1417                 a[i] = v;
1418             }
1419         }
1420     }
1421 
1422     static short ROL_scalar(short a, short b) {
1423         return (short)(((((short)a) & 0xFFFF) << (b & 15)) | ((((short)a) & 0xFFFF) >>> (16 - (b & 15))));
1424     }
1425 
1426     static short ROR_scalar(short a, short b) {
1427         return (short)(((((short)a) & 0xFFFF) >>> (b & 15)) | ((((short)a) & 0xFFFF) << (16 - (b & 15))));
1428     }
1429 
1430     static short TRAILING_ZEROS_COUNT_scalar(short a) {
1431         return (short) (a != 0 ? Integer.numberOfTrailingZeros(a) : 16);
1432     }
1433 
1434     static short LEADING_ZEROS_COUNT_scalar(short a) {
1435         return (short) (a >= 0 ? Integer.numberOfLeadingZeros(a) - 16 : 0);
1436     }
1437 
1438     static short REVERSE_scalar(short a) {
1439         short b = ROL_scalar(a, (short) 8);
1440         b = (short) (((b & 0x5555) << 1) | ((b & 0xAAAA) >>> 1));
1441         b = (short) (((b & 0x3333) << 2) | ((b & 0xCCCC) >>> 2));
1442         b = (short) (((b & 0x0F0F) << 4) | ((b & 0xF0F0) >>> 4));
1443         return b;
1444     }
1445 
1446     static boolean eq(short a, short b) {
1447         return a == b;
1448     }
1449 
1450     static boolean neq(short a, short b) {
1451         return a != b;
1452     }
1453 
1454     static boolean lt(short a, short b) {
1455         return a < b;
1456     }
1457 
1458     static boolean le(short a, short b) {
1459         return a <= b;
1460     }
1461 
1462     static boolean gt(short a, short b) {
1463         return a > b;
1464     }
1465 
1466     static boolean ge(short a, short b) {
1467         return a >= b;
1468     }
1469 
1470     static boolean ult(short a, short b) {
1471         return Short.compareUnsigned(a, b) < 0;
1472     }
1473 
1474     static boolean ule(short a, short b) {
1475         return Short.compareUnsigned(a, b) <= 0;
1476     }
1477 
1478     static boolean ugt(short a, short b) {
1479         return Short.compareUnsigned(a, b) > 0;
1480     }
1481 
1482     static boolean uge(short a, short b) {
1483         return Short.compareUnsigned(a, b) >= 0;
1484     }
1485 
1486     static short firstNonZero(short a, short b) {
1487         return Short.compare(a, (short) 0) != 0 ? a : b;
1488     }
1489 
1490     @Test
1491     static void smokeTest1() {
1492         ShortVector three = ShortVector.broadcast(SPECIES, (byte)-3);
1493         ShortVector three2 = (ShortVector) SPECIES.broadcast(-3);
1494         assert(three.eq(three2).allTrue());
1495         ShortVector three3 = three2.broadcast(1).broadcast(-3);
1496         assert(three.eq(three3).allTrue());
1497         int scale = 2;
1498         Class<?> ETYPE = short.class;
1499         if (ETYPE == double.class || ETYPE == long.class)
1500             scale = 1000000;
1501         else if (ETYPE == byte.class && SPECIES.length() >= 64)
1502             scale = 1;
1503         ShortVector higher = three.addIndex(scale);
1504         VectorMask<Short> m = three.compare(VectorOperators.LE, higher);
1505         assert(m.allTrue());
1506         m = higher.min((short)-1).test(VectorOperators.IS_NEGATIVE);
1507         assert(m.allTrue());
1508         short max = higher.reduceLanes(VectorOperators.MAX);
1509         assert(max == -3 + scale * (SPECIES.length()-1));
1510     }
1511 
1512     private static short[]
1513     bothToArray(ShortVector a, ShortVector b) {
1514         short[] r = new short[a.length() + b.length()];
1515         a.intoArray(r, 0);
1516         b.intoArray(r, a.length());
1517         return r;
1518     }
1519 
1520     @Test
1521     static void smokeTest2() {
1522         // Do some zipping and shuffling.
1523         ShortVector io = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1524         ShortVector io2 = (ShortVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1525         Assert.assertEquals(io, io2);
1526         ShortVector a = io.add((short)1); //[1,2]
1527         ShortVector b = a.neg();  //[-1,-2]
1528         short[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1529         VectorShuffle<Short> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1530         VectorShuffle<Short> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1531         ShortVector zab0 = a.rearrange(zip0,b); //[1,-1]
1532         ShortVector zab1 = a.rearrange(zip1,b); //[2,-2]
1533         short[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1534         // manually zip
1535         short[] manual = new short[zabValues.length];
1536         for (int i = 0; i < manual.length; i += 2) {
1537             manual[i+0] = abValues[i/2];
1538             manual[i+1] = abValues[a.length() + i/2];
1539         }
1540         Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1541         VectorShuffle<Short> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1542         VectorShuffle<Short> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1543         ShortVector uab0 = zab0.rearrange(unz0,zab1);
1544         ShortVector uab1 = zab0.rearrange(unz1,zab1);
1545         short[] abValues1 = bothToArray(uab0, uab1);
1546         Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1547     }
1548 
1549     static void iotaShuffle() {
1550         ShortVector io = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1551         ShortVector io2 = (ShortVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1552         Assert.assertEquals(io, io2);
1553     }
1554 
1555     @Test
1556     // Test all shuffle related operations.
1557     static void shuffleTest() {
1558         // To test backend instructions, make sure that C2 is used.
1559         for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1560             iotaShuffle();
1561         }
1562     }
1563 
1564     @Test
1565     void viewAsIntegeralLanesTest() {
1566         Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1567         Assert.assertEquals(asIntegral.species(), SPECIES);
1568     }
1569 
1570     @Test(expectedExceptions = UnsupportedOperationException.class)
1571     void viewAsFloatingLanesTest() {
1572         SPECIES.zero().viewAsFloatingLanes();
1573     }
1574 
1575     @Test
1576     // Test div by 0.
1577     static void bitwiseDivByZeroSmokeTest() {
1578         try {
1579             ShortVector a = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1580             ShortVector b = (ShortVector) SPECIES.broadcast(0);
1581             a.div(b);
1582             Assert.fail();
1583         } catch (ArithmeticException e) {
1584         }
1585 
1586         try {
1587             ShortVector a = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1588             ShortVector b = (ShortVector) SPECIES.broadcast(0);
1589             VectorMask<Short> m = a.lt((short) 1);
1590             a.div(b, m);
1591             Assert.fail();
1592         } catch (ArithmeticException e) {
1593         }
1594     }
1595 
1596     static short ADD(short a, short b) {
1597         return (short)(a + b);
1598     }
1599 
1600     @Test(dataProvider = "shortBinaryOpProvider")
1601     static void ADDShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1602         short[] a = fa.apply(SPECIES.length());
1603         short[] b = fb.apply(SPECIES.length());
1604         short[] r = fr.apply(SPECIES.length());
1605 
1606         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1607             for (int i = 0; i < a.length; i += SPECIES.length()) {
1608                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1609                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1610                 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1611             }
1612         }
1613 
1614         assertArraysEquals(r, a, b, Short512VectorTests::ADD);
1615     }
1616 
1617     static short add(short a, short b) {
1618         return (short)(a + b);
1619     }
1620 
1621     @Test(dataProvider = "shortBinaryOpProvider")
1622     static void addShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1623         short[] a = fa.apply(SPECIES.length());
1624         short[] b = fb.apply(SPECIES.length());
1625         short[] r = fr.apply(SPECIES.length());
1626 
1627         for (int i = 0; i < a.length; i += SPECIES.length()) {
1628             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1629             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1630             av.add(bv).intoArray(r, i);
1631         }
1632 
1633         assertArraysEquals(r, a, b, Short512VectorTests::add);
1634     }
1635 
1636     @Test(dataProvider = "shortBinaryOpMaskProvider")
1637     static void ADDShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1638                                           IntFunction<boolean[]> fm) {
1639         short[] a = fa.apply(SPECIES.length());
1640         short[] b = fb.apply(SPECIES.length());
1641         short[] r = fr.apply(SPECIES.length());
1642         boolean[] mask = fm.apply(SPECIES.length());
1643         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1644 
1645         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1646             for (int i = 0; i < a.length; i += SPECIES.length()) {
1647                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1648                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1649                 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1650             }
1651         }
1652 
1653         assertArraysEquals(r, a, b, mask, Short512VectorTests::ADD);
1654     }
1655 
1656     @Test(dataProvider = "shortBinaryOpMaskProvider")
1657     static void addShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1658                                           IntFunction<boolean[]> fm) {
1659         short[] a = fa.apply(SPECIES.length());
1660         short[] b = fb.apply(SPECIES.length());
1661         short[] r = fr.apply(SPECIES.length());
1662         boolean[] mask = fm.apply(SPECIES.length());
1663         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1664 
1665         for (int i = 0; i < a.length; i += SPECIES.length()) {
1666             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1667             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1668             av.add(bv, vmask).intoArray(r, i);
1669         }
1670 
1671         assertArraysEquals(r, a, b, mask, Short512VectorTests::add);
1672     }
1673 
1674     static short SUB(short a, short b) {
1675         return (short)(a - b);
1676     }
1677 
1678     @Test(dataProvider = "shortBinaryOpProvider")
1679     static void SUBShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1680         short[] a = fa.apply(SPECIES.length());
1681         short[] b = fb.apply(SPECIES.length());
1682         short[] r = fr.apply(SPECIES.length());
1683 
1684         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1685             for (int i = 0; i < a.length; i += SPECIES.length()) {
1686                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1687                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1688                 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1689             }
1690         }
1691 
1692         assertArraysEquals(r, a, b, Short512VectorTests::SUB);
1693     }
1694 
1695     static short sub(short a, short b) {
1696         return (short)(a - b);
1697     }
1698 
1699     @Test(dataProvider = "shortBinaryOpProvider")
1700     static void subShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1701         short[] a = fa.apply(SPECIES.length());
1702         short[] b = fb.apply(SPECIES.length());
1703         short[] r = fr.apply(SPECIES.length());
1704 
1705         for (int i = 0; i < a.length; i += SPECIES.length()) {
1706             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1707             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1708             av.sub(bv).intoArray(r, i);
1709         }
1710 
1711         assertArraysEquals(r, a, b, Short512VectorTests::sub);
1712     }
1713 
1714     @Test(dataProvider = "shortBinaryOpMaskProvider")
1715     static void SUBShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1716                                           IntFunction<boolean[]> fm) {
1717         short[] a = fa.apply(SPECIES.length());
1718         short[] b = fb.apply(SPECIES.length());
1719         short[] r = fr.apply(SPECIES.length());
1720         boolean[] mask = fm.apply(SPECIES.length());
1721         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1722 
1723         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1724             for (int i = 0; i < a.length; i += SPECIES.length()) {
1725                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1726                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1727                 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1728             }
1729         }
1730 
1731         assertArraysEquals(r, a, b, mask, Short512VectorTests::SUB);
1732     }
1733 
1734     @Test(dataProvider = "shortBinaryOpMaskProvider")
1735     static void subShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1736                                           IntFunction<boolean[]> fm) {
1737         short[] a = fa.apply(SPECIES.length());
1738         short[] b = fb.apply(SPECIES.length());
1739         short[] r = fr.apply(SPECIES.length());
1740         boolean[] mask = fm.apply(SPECIES.length());
1741         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1742 
1743         for (int i = 0; i < a.length; i += SPECIES.length()) {
1744             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1745             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1746             av.sub(bv, vmask).intoArray(r, i);
1747         }
1748 
1749         assertArraysEquals(r, a, b, mask, Short512VectorTests::sub);
1750     }
1751 
1752     static short MUL(short a, short b) {
1753         return (short)(a * b);
1754     }
1755 
1756     @Test(dataProvider = "shortBinaryOpProvider")
1757     static void MULShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1758         short[] a = fa.apply(SPECIES.length());
1759         short[] b = fb.apply(SPECIES.length());
1760         short[] r = fr.apply(SPECIES.length());
1761 
1762         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1763             for (int i = 0; i < a.length; i += SPECIES.length()) {
1764                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1765                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1766                 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1767             }
1768         }
1769 
1770         assertArraysEquals(r, a, b, Short512VectorTests::MUL);
1771     }
1772 
1773     static short mul(short a, short b) {
1774         return (short)(a * b);
1775     }
1776 
1777     @Test(dataProvider = "shortBinaryOpProvider")
1778     static void mulShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1779         short[] a = fa.apply(SPECIES.length());
1780         short[] b = fb.apply(SPECIES.length());
1781         short[] r = fr.apply(SPECIES.length());
1782 
1783         for (int i = 0; i < a.length; i += SPECIES.length()) {
1784             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1785             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1786             av.mul(bv).intoArray(r, i);
1787         }
1788 
1789         assertArraysEquals(r, a, b, Short512VectorTests::mul);
1790     }
1791 
1792     @Test(dataProvider = "shortBinaryOpMaskProvider")
1793     static void MULShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1794                                           IntFunction<boolean[]> fm) {
1795         short[] a = fa.apply(SPECIES.length());
1796         short[] b = fb.apply(SPECIES.length());
1797         short[] r = fr.apply(SPECIES.length());
1798         boolean[] mask = fm.apply(SPECIES.length());
1799         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1800 
1801         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1802             for (int i = 0; i < a.length; i += SPECIES.length()) {
1803                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1804                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1805                 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1806             }
1807         }
1808 
1809         assertArraysEquals(r, a, b, mask, Short512VectorTests::MUL);
1810     }
1811 
1812     @Test(dataProvider = "shortBinaryOpMaskProvider")
1813     static void mulShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1814                                           IntFunction<boolean[]> fm) {
1815         short[] a = fa.apply(SPECIES.length());
1816         short[] b = fb.apply(SPECIES.length());
1817         short[] r = fr.apply(SPECIES.length());
1818         boolean[] mask = fm.apply(SPECIES.length());
1819         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1820 
1821         for (int i = 0; i < a.length; i += SPECIES.length()) {
1822             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1823             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1824             av.mul(bv, vmask).intoArray(r, i);
1825         }
1826 
1827         assertArraysEquals(r, a, b, mask, Short512VectorTests::mul);
1828     }
1829 
1830     static short DIV(short a, short b) {
1831         return (short)(a / b);
1832     }
1833 
1834     @Test(dataProvider = "shortBinaryOpProvider")
1835     static void DIVShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1836         short[] a = fa.apply(SPECIES.length());
1837         short[] b = fb.apply(SPECIES.length());
1838         short[] r = fr.apply(SPECIES.length());
1839 
1840         replaceZero(b, (short) 1);
1841 
1842         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1843             for (int i = 0; i < a.length; i += SPECIES.length()) {
1844                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1845                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1846                 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1847             }
1848         }
1849 
1850         assertArraysEquals(r, a, b, Short512VectorTests::DIV);
1851     }
1852 
1853     static short div(short a, short b) {
1854         return (short)(a / b);
1855     }
1856 
1857     @Test(dataProvider = "shortBinaryOpProvider")
1858     static void divShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1859         short[] a = fa.apply(SPECIES.length());
1860         short[] b = fb.apply(SPECIES.length());
1861         short[] r = fr.apply(SPECIES.length());
1862 
1863         replaceZero(b, (short) 1);
1864 
1865         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1866             for (int i = 0; i < a.length; i += SPECIES.length()) {
1867                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1868                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1869                 av.div(bv).intoArray(r, i);
1870             }
1871         }
1872 
1873         assertArraysEquals(r, a, b, Short512VectorTests::div);
1874     }
1875 
1876     @Test(dataProvider = "shortBinaryOpMaskProvider")
1877     static void DIVShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1878                                           IntFunction<boolean[]> fm) {
1879         short[] a = fa.apply(SPECIES.length());
1880         short[] b = fb.apply(SPECIES.length());
1881         short[] r = fr.apply(SPECIES.length());
1882         boolean[] mask = fm.apply(SPECIES.length());
1883         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1884 
1885         replaceZero(b, mask, (short) 1);
1886 
1887         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1888             for (int i = 0; i < a.length; i += SPECIES.length()) {
1889                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1890                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1891                 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1892             }
1893         }
1894 
1895         assertArraysEquals(r, a, b, mask, Short512VectorTests::DIV);
1896     }
1897 
1898     @Test(dataProvider = "shortBinaryOpMaskProvider")
1899     static void divShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1900                                           IntFunction<boolean[]> fm) {
1901         short[] a = fa.apply(SPECIES.length());
1902         short[] b = fb.apply(SPECIES.length());
1903         short[] r = fr.apply(SPECIES.length());
1904         boolean[] mask = fm.apply(SPECIES.length());
1905         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1906 
1907         replaceZero(b, mask, (short) 1);
1908 
1909         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1910             for (int i = 0; i < a.length; i += SPECIES.length()) {
1911                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1912                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1913                 av.div(bv, vmask).intoArray(r, i);
1914             }
1915         }
1916 
1917         assertArraysEquals(r, a, b, mask, Short512VectorTests::div);
1918     }
1919 
1920     static short FIRST_NONZERO(short a, short b) {
1921         return (short)((a)!=0?a:b);
1922     }
1923 
1924     @Test(dataProvider = "shortBinaryOpProvider")
1925     static void FIRST_NONZEROShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1926         short[] a = fa.apply(SPECIES.length());
1927         short[] b = fb.apply(SPECIES.length());
1928         short[] r = fr.apply(SPECIES.length());
1929 
1930         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1931             for (int i = 0; i < a.length; i += SPECIES.length()) {
1932                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1933                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1934                 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1935             }
1936         }
1937 
1938         assertArraysEquals(r, a, b, Short512VectorTests::FIRST_NONZERO);
1939     }
1940 
1941     @Test(dataProvider = "shortBinaryOpMaskProvider")
1942     static void FIRST_NONZEROShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1943                                           IntFunction<boolean[]> fm) {
1944         short[] a = fa.apply(SPECIES.length());
1945         short[] b = fb.apply(SPECIES.length());
1946         short[] r = fr.apply(SPECIES.length());
1947         boolean[] mask = fm.apply(SPECIES.length());
1948         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1949 
1950         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1951             for (int i = 0; i < a.length; i += SPECIES.length()) {
1952                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1953                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1954                 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1955             }
1956         }
1957 
1958         assertArraysEquals(r, a, b, mask, Short512VectorTests::FIRST_NONZERO);
1959     }
1960 
1961     static short AND(short a, short b) {
1962         return (short)(a & b);
1963     }
1964 
1965     @Test(dataProvider = "shortBinaryOpProvider")
1966     static void ANDShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1967         short[] a = fa.apply(SPECIES.length());
1968         short[] b = fb.apply(SPECIES.length());
1969         short[] r = fr.apply(SPECIES.length());
1970 
1971         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1972             for (int i = 0; i < a.length; i += SPECIES.length()) {
1973                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1974                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1975                 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1976             }
1977         }
1978 
1979         assertArraysEquals(r, a, b, Short512VectorTests::AND);
1980     }
1981 
1982     static short and(short a, short b) {
1983         return (short)(a & b);
1984     }
1985 
1986     @Test(dataProvider = "shortBinaryOpProvider")
1987     static void andShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1988         short[] a = fa.apply(SPECIES.length());
1989         short[] b = fb.apply(SPECIES.length());
1990         short[] r = fr.apply(SPECIES.length());
1991 
1992         for (int i = 0; i < a.length; i += SPECIES.length()) {
1993             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1994             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1995             av.and(bv).intoArray(r, i);
1996         }
1997 
1998         assertArraysEquals(r, a, b, Short512VectorTests::and);
1999     }
2000 
2001     @Test(dataProvider = "shortBinaryOpMaskProvider")
2002     static void ANDShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2003                                           IntFunction<boolean[]> fm) {
2004         short[] a = fa.apply(SPECIES.length());
2005         short[] b = fb.apply(SPECIES.length());
2006         short[] r = fr.apply(SPECIES.length());
2007         boolean[] mask = fm.apply(SPECIES.length());
2008         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2009 
2010         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2011             for (int i = 0; i < a.length; i += SPECIES.length()) {
2012                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2013                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2014                 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
2015             }
2016         }
2017 
2018         assertArraysEquals(r, a, b, mask, Short512VectorTests::AND);
2019     }
2020 
2021     static short AND_NOT(short a, short b) {
2022         return (short)(a & ~b);
2023     }
2024 
2025     @Test(dataProvider = "shortBinaryOpProvider")
2026     static void AND_NOTShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2027         short[] a = fa.apply(SPECIES.length());
2028         short[] b = fb.apply(SPECIES.length());
2029         short[] r = fr.apply(SPECIES.length());
2030 
2031         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2032             for (int i = 0; i < a.length; i += SPECIES.length()) {
2033                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2034                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2035                 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
2036             }
2037         }
2038 
2039         assertArraysEquals(r, a, b, Short512VectorTests::AND_NOT);
2040     }
2041 
2042     @Test(dataProvider = "shortBinaryOpMaskProvider")
2043     static void AND_NOTShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2044                                           IntFunction<boolean[]> fm) {
2045         short[] a = fa.apply(SPECIES.length());
2046         short[] b = fb.apply(SPECIES.length());
2047         short[] r = fr.apply(SPECIES.length());
2048         boolean[] mask = fm.apply(SPECIES.length());
2049         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2050 
2051         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2052             for (int i = 0; i < a.length; i += SPECIES.length()) {
2053                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2054                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2055                 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
2056             }
2057         }
2058 
2059         assertArraysEquals(r, a, b, mask, Short512VectorTests::AND_NOT);
2060     }
2061 
2062     static short OR(short a, short b) {
2063         return (short)(a | b);
2064     }
2065 
2066     @Test(dataProvider = "shortBinaryOpProvider")
2067     static void ORShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2068         short[] a = fa.apply(SPECIES.length());
2069         short[] b = fb.apply(SPECIES.length());
2070         short[] r = fr.apply(SPECIES.length());
2071 
2072         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2073             for (int i = 0; i < a.length; i += SPECIES.length()) {
2074                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2075                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2076                 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
2077             }
2078         }
2079 
2080         assertArraysEquals(r, a, b, Short512VectorTests::OR);
2081     }
2082 
2083     static short or(short a, short b) {
2084         return (short)(a | b);
2085     }
2086 
2087     @Test(dataProvider = "shortBinaryOpProvider")
2088     static void orShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2089         short[] a = fa.apply(SPECIES.length());
2090         short[] b = fb.apply(SPECIES.length());
2091         short[] r = fr.apply(SPECIES.length());
2092 
2093         for (int i = 0; i < a.length; i += SPECIES.length()) {
2094             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2095             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2096             av.or(bv).intoArray(r, i);
2097         }
2098 
2099         assertArraysEquals(r, a, b, Short512VectorTests::or);
2100     }
2101 
2102     @Test(dataProvider = "shortBinaryOpMaskProvider")
2103     static void ORShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2104                                           IntFunction<boolean[]> fm) {
2105         short[] a = fa.apply(SPECIES.length());
2106         short[] b = fb.apply(SPECIES.length());
2107         short[] r = fr.apply(SPECIES.length());
2108         boolean[] mask = fm.apply(SPECIES.length());
2109         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2110 
2111         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2112             for (int i = 0; i < a.length; i += SPECIES.length()) {
2113                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2114                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2115                 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
2116             }
2117         }
2118 
2119         assertArraysEquals(r, a, b, mask, Short512VectorTests::OR);
2120     }
2121 
2122     static short XOR(short a, short b) {
2123         return (short)(a ^ b);
2124     }
2125 
2126     @Test(dataProvider = "shortBinaryOpProvider")
2127     static void XORShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2128         short[] a = fa.apply(SPECIES.length());
2129         short[] b = fb.apply(SPECIES.length());
2130         short[] r = fr.apply(SPECIES.length());
2131 
2132         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2133             for (int i = 0; i < a.length; i += SPECIES.length()) {
2134                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2135                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2136                 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
2137             }
2138         }
2139 
2140         assertArraysEquals(r, a, b, Short512VectorTests::XOR);
2141     }
2142 
2143     @Test(dataProvider = "shortBinaryOpMaskProvider")
2144     static void XORShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2145                                           IntFunction<boolean[]> fm) {
2146         short[] a = fa.apply(SPECIES.length());
2147         short[] b = fb.apply(SPECIES.length());
2148         short[] r = fr.apply(SPECIES.length());
2149         boolean[] mask = fm.apply(SPECIES.length());
2150         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2151 
2152         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2153             for (int i = 0; i < a.length; i += SPECIES.length()) {
2154                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2155                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2156                 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
2157             }
2158         }
2159 
2160         assertArraysEquals(r, a, b, mask, Short512VectorTests::XOR);
2161     }
2162 
2163     @Test(dataProvider = "shortBinaryOpProvider")
2164     static void addShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2165         short[] a = fa.apply(SPECIES.length());
2166         short[] b = fb.apply(SPECIES.length());
2167         short[] r = fr.apply(SPECIES.length());
2168 
2169         for (int i = 0; i < a.length; i += SPECIES.length()) {
2170             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2171             av.add(b[i]).intoArray(r, i);
2172         }
2173 
2174         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::add);
2175     }
2176 
2177     @Test(dataProvider = "shortBinaryOpMaskProvider")
2178     static void addShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2179                                           IntFunction<boolean[]> fm) {
2180         short[] a = fa.apply(SPECIES.length());
2181         short[] b = fb.apply(SPECIES.length());
2182         short[] r = fr.apply(SPECIES.length());
2183         boolean[] mask = fm.apply(SPECIES.length());
2184         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2185 
2186         for (int i = 0; i < a.length; i += SPECIES.length()) {
2187             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2188             av.add(b[i], vmask).intoArray(r, i);
2189         }
2190 
2191         assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::add);
2192     }
2193 
2194     @Test(dataProvider = "shortBinaryOpProvider")
2195     static void subShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2196         short[] a = fa.apply(SPECIES.length());
2197         short[] b = fb.apply(SPECIES.length());
2198         short[] r = fr.apply(SPECIES.length());
2199 
2200         for (int i = 0; i < a.length; i += SPECIES.length()) {
2201             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2202             av.sub(b[i]).intoArray(r, i);
2203         }
2204 
2205         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::sub);
2206     }
2207 
2208     @Test(dataProvider = "shortBinaryOpMaskProvider")
2209     static void subShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2210                                           IntFunction<boolean[]> fm) {
2211         short[] a = fa.apply(SPECIES.length());
2212         short[] b = fb.apply(SPECIES.length());
2213         short[] r = fr.apply(SPECIES.length());
2214         boolean[] mask = fm.apply(SPECIES.length());
2215         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2216 
2217         for (int i = 0; i < a.length; i += SPECIES.length()) {
2218             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2219             av.sub(b[i], vmask).intoArray(r, i);
2220         }
2221 
2222         assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::sub);
2223     }
2224 
2225     @Test(dataProvider = "shortBinaryOpProvider")
2226     static void mulShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2227         short[] a = fa.apply(SPECIES.length());
2228         short[] b = fb.apply(SPECIES.length());
2229         short[] r = fr.apply(SPECIES.length());
2230 
2231         for (int i = 0; i < a.length; i += SPECIES.length()) {
2232             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2233             av.mul(b[i]).intoArray(r, i);
2234         }
2235 
2236         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::mul);
2237     }
2238 
2239     @Test(dataProvider = "shortBinaryOpMaskProvider")
2240     static void mulShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2241                                           IntFunction<boolean[]> fm) {
2242         short[] a = fa.apply(SPECIES.length());
2243         short[] b = fb.apply(SPECIES.length());
2244         short[] r = fr.apply(SPECIES.length());
2245         boolean[] mask = fm.apply(SPECIES.length());
2246         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2247 
2248         for (int i = 0; i < a.length; i += SPECIES.length()) {
2249             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2250             av.mul(b[i], vmask).intoArray(r, i);
2251         }
2252 
2253         assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::mul);
2254     }
2255 
2256     @Test(dataProvider = "shortBinaryOpProvider")
2257     static void divShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2258         short[] a = fa.apply(SPECIES.length());
2259         short[] b = fb.apply(SPECIES.length());
2260         short[] r = fr.apply(SPECIES.length());
2261 
2262         replaceZero(b, (short) 1);
2263 
2264         for (int i = 0; i < a.length; i += SPECIES.length()) {
2265             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2266             av.div(b[i]).intoArray(r, i);
2267         }
2268 
2269         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::div);
2270     }
2271 
2272     @Test(dataProvider = "shortBinaryOpMaskProvider")
2273     static void divShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2274                                           IntFunction<boolean[]> fm) {
2275         short[] a = fa.apply(SPECIES.length());
2276         short[] b = fb.apply(SPECIES.length());
2277         short[] r = fr.apply(SPECIES.length());
2278         boolean[] mask = fm.apply(SPECIES.length());
2279         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2280 
2281         replaceZero(b, (short) 1);
2282 
2283         for (int i = 0; i < a.length; i += SPECIES.length()) {
2284             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2285             av.div(b[i], vmask).intoArray(r, i);
2286         }
2287 
2288         assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::div);
2289     }
2290 
2291     @Test(dataProvider = "shortBinaryOpProvider")
2292     static void ORShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2293         short[] a = fa.apply(SPECIES.length());
2294         short[] b = fb.apply(SPECIES.length());
2295         short[] r = fr.apply(SPECIES.length());
2296 
2297         for (int i = 0; i < a.length; i += SPECIES.length()) {
2298             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2299             av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
2300         }
2301 
2302         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::OR);
2303     }
2304 
2305     @Test(dataProvider = "shortBinaryOpProvider")
2306     static void orShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2307         short[] a = fa.apply(SPECIES.length());
2308         short[] b = fb.apply(SPECIES.length());
2309         short[] r = fr.apply(SPECIES.length());
2310 
2311         for (int i = 0; i < a.length; i += SPECIES.length()) {
2312             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2313             av.or(b[i]).intoArray(r, i);
2314         }
2315 
2316         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::or);
2317     }
2318 
2319     @Test(dataProvider = "shortBinaryOpMaskProvider")
2320     static void ORShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2321                                           IntFunction<boolean[]> fm) {
2322         short[] a = fa.apply(SPECIES.length());
2323         short[] b = fb.apply(SPECIES.length());
2324         short[] r = fr.apply(SPECIES.length());
2325         boolean[] mask = fm.apply(SPECIES.length());
2326         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2327 
2328         for (int i = 0; i < a.length; i += SPECIES.length()) {
2329             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2330             av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
2331         }
2332 
2333         assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::OR);
2334     }
2335 
2336     @Test(dataProvider = "shortBinaryOpProvider")
2337     static void ANDShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2338         short[] a = fa.apply(SPECIES.length());
2339         short[] b = fb.apply(SPECIES.length());
2340         short[] r = fr.apply(SPECIES.length());
2341 
2342         for (int i = 0; i < a.length; i += SPECIES.length()) {
2343             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2344             av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
2345         }
2346 
2347         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::AND);
2348     }
2349 
2350     @Test(dataProvider = "shortBinaryOpProvider")
2351     static void andShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2352         short[] a = fa.apply(SPECIES.length());
2353         short[] b = fb.apply(SPECIES.length());
2354         short[] r = fr.apply(SPECIES.length());
2355 
2356         for (int i = 0; i < a.length; i += SPECIES.length()) {
2357             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2358             av.and(b[i]).intoArray(r, i);
2359         }
2360 
2361         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::and);
2362     }
2363 
2364     @Test(dataProvider = "shortBinaryOpMaskProvider")
2365     static void ANDShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2366                                           IntFunction<boolean[]> fm) {
2367         short[] a = fa.apply(SPECIES.length());
2368         short[] b = fb.apply(SPECIES.length());
2369         short[] r = fr.apply(SPECIES.length());
2370         boolean[] mask = fm.apply(SPECIES.length());
2371         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2372 
2373         for (int i = 0; i < a.length; i += SPECIES.length()) {
2374             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2375             av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
2376         }
2377 
2378         assertBroadcastArraysEquals(r, a, b, mask, Short512VectorTests::AND);
2379     }
2380 
2381     @Test(dataProvider = "shortBinaryOpProvider")
2382     static void ORShort512VectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2383         short[] a = fa.apply(SPECIES.length());
2384         short[] b = fb.apply(SPECIES.length());
2385         short[] r = fr.apply(SPECIES.length());
2386 
2387         for (int i = 0; i < a.length; i += SPECIES.length()) {
2388             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2389             av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
2390         }
2391 
2392         assertBroadcastLongArraysEquals(r, a, b, Short512VectorTests::OR);
2393     }
2394 
2395     @Test(dataProvider = "shortBinaryOpMaskProvider")
2396     static void ORShort512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2397                                           IntFunction<boolean[]> fm) {
2398         short[] a = fa.apply(SPECIES.length());
2399         short[] b = fb.apply(SPECIES.length());
2400         short[] r = fr.apply(SPECIES.length());
2401         boolean[] mask = fm.apply(SPECIES.length());
2402         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2403 
2404         for (int i = 0; i < a.length; i += SPECIES.length()) {
2405             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2406             av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
2407         }
2408 
2409         assertBroadcastLongArraysEquals(r, a, b, mask, Short512VectorTests::OR);
2410     }
2411 
2412     @Test(dataProvider = "shortBinaryOpProvider")
2413     static void ADDShort512VectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2414         short[] a = fa.apply(SPECIES.length());
2415         short[] b = fb.apply(SPECIES.length());
2416         short[] r = fr.apply(SPECIES.length());
2417 
2418         for (int i = 0; i < a.length; i += SPECIES.length()) {
2419             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2420             av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2421         }
2422 
2423         assertBroadcastLongArraysEquals(r, a, b, Short512VectorTests::ADD);
2424     }
2425 
2426     @Test(dataProvider = "shortBinaryOpMaskProvider")
2427     static void ADDShort512VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2428                                           IntFunction<boolean[]> fm) {
2429         short[] a = fa.apply(SPECIES.length());
2430         short[] b = fb.apply(SPECIES.length());
2431         short[] r = fr.apply(SPECIES.length());
2432         boolean[] mask = fm.apply(SPECIES.length());
2433         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2434 
2435         for (int i = 0; i < a.length; i += SPECIES.length()) {
2436             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2437             av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2438         }
2439 
2440         assertBroadcastLongArraysEquals(r, a, b, mask, Short512VectorTests::ADD);
2441     }
2442 
2443     static short LSHL(short a, short b) {
2444         return (short)((a << (b & 0xF)));
2445     }
2446 
2447     @Test(dataProvider = "shortBinaryOpProvider")
2448     static void LSHLShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2449         short[] a = fa.apply(SPECIES.length());
2450         short[] b = fb.apply(SPECIES.length());
2451         short[] r = fr.apply(SPECIES.length());
2452 
2453         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2454             for (int i = 0; i < a.length; i += SPECIES.length()) {
2455                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2456                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2457                 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
2458             }
2459         }
2460 
2461         assertArraysEquals(r, a, b, Short512VectorTests::LSHL);
2462     }
2463 
2464     @Test(dataProvider = "shortBinaryOpMaskProvider")
2465     static void LSHLShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2466                                           IntFunction<boolean[]> fm) {
2467         short[] a = fa.apply(SPECIES.length());
2468         short[] b = fb.apply(SPECIES.length());
2469         short[] r = fr.apply(SPECIES.length());
2470         boolean[] mask = fm.apply(SPECIES.length());
2471         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2472 
2473         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2474             for (int i = 0; i < a.length; i += SPECIES.length()) {
2475                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2476                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2477                 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
2478             }
2479         }
2480 
2481         assertArraysEquals(r, a, b, mask, Short512VectorTests::LSHL);
2482     }
2483 
2484     static short ASHR(short a, short b) {
2485         return (short)((a >> (b & 0xF)));
2486     }
2487 
2488     @Test(dataProvider = "shortBinaryOpProvider")
2489     static void ASHRShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2490         short[] a = fa.apply(SPECIES.length());
2491         short[] b = fb.apply(SPECIES.length());
2492         short[] r = fr.apply(SPECIES.length());
2493 
2494         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2495             for (int i = 0; i < a.length; i += SPECIES.length()) {
2496                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2497                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2498                 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
2499             }
2500         }
2501 
2502         assertArraysEquals(r, a, b, Short512VectorTests::ASHR);
2503     }
2504 
2505     @Test(dataProvider = "shortBinaryOpMaskProvider")
2506     static void ASHRShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2507                                           IntFunction<boolean[]> fm) {
2508         short[] a = fa.apply(SPECIES.length());
2509         short[] b = fb.apply(SPECIES.length());
2510         short[] r = fr.apply(SPECIES.length());
2511         boolean[] mask = fm.apply(SPECIES.length());
2512         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2513 
2514         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2515             for (int i = 0; i < a.length; i += SPECIES.length()) {
2516                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2517                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2518                 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
2519             }
2520         }
2521 
2522         assertArraysEquals(r, a, b, mask, Short512VectorTests::ASHR);
2523     }
2524 
2525     static short LSHR(short a, short b) {
2526         return (short)(((a & 0xFFFF) >>> (b & 0xF)));
2527     }
2528 
2529     @Test(dataProvider = "shortBinaryOpProvider")
2530     static void LSHRShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2531         short[] a = fa.apply(SPECIES.length());
2532         short[] b = fb.apply(SPECIES.length());
2533         short[] r = fr.apply(SPECIES.length());
2534 
2535         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2536             for (int i = 0; i < a.length; i += SPECIES.length()) {
2537                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2538                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2539                 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
2540             }
2541         }
2542 
2543         assertArraysEquals(r, a, b, Short512VectorTests::LSHR);
2544     }
2545 
2546     @Test(dataProvider = "shortBinaryOpMaskProvider")
2547     static void LSHRShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2548                                           IntFunction<boolean[]> fm) {
2549         short[] a = fa.apply(SPECIES.length());
2550         short[] b = fb.apply(SPECIES.length());
2551         short[] r = fr.apply(SPECIES.length());
2552         boolean[] mask = fm.apply(SPECIES.length());
2553         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2554 
2555         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2556             for (int i = 0; i < a.length; i += SPECIES.length()) {
2557                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2558                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2559                 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
2560             }
2561         }
2562 
2563         assertArraysEquals(r, a, b, mask, Short512VectorTests::LSHR);
2564     }
2565 
2566     static short LSHL_unary(short a, short b) {
2567         return (short)((a << (b & 15)));
2568     }
2569 
2570     @Test(dataProvider = "shortBinaryOpProvider")
2571     static void LSHLShort512VectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2572         short[] a = fa.apply(SPECIES.length());
2573         short[] b = fb.apply(SPECIES.length());
2574         short[] r = fr.apply(SPECIES.length());
2575 
2576         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2577             for (int i = 0; i < a.length; i += SPECIES.length()) {
2578                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2579                 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
2580             }
2581         }
2582 
2583         assertShiftArraysEquals(r, a, b, Short512VectorTests::LSHL_unary);
2584     }
2585 
2586     @Test(dataProvider = "shortBinaryOpMaskProvider")
2587     static void LSHLShort512VectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2588                                           IntFunction<boolean[]> fm) {
2589         short[] a = fa.apply(SPECIES.length());
2590         short[] b = fb.apply(SPECIES.length());
2591         short[] r = fr.apply(SPECIES.length());
2592         boolean[] mask = fm.apply(SPECIES.length());
2593         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2594 
2595         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2596             for (int i = 0; i < a.length; i += SPECIES.length()) {
2597                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2598                 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
2599             }
2600         }
2601 
2602         assertShiftArraysEquals(r, a, b, mask, Short512VectorTests::LSHL_unary);
2603     }
2604 
2605     static short LSHR_unary(short a, short b) {
2606         return (short)(((a & 0xFFFF) >>> (b & 15)));
2607     }
2608 
2609     @Test(dataProvider = "shortBinaryOpProvider")
2610     static void LSHRShort512VectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2611         short[] a = fa.apply(SPECIES.length());
2612         short[] b = fb.apply(SPECIES.length());
2613         short[] r = fr.apply(SPECIES.length());
2614 
2615         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2616             for (int i = 0; i < a.length; i += SPECIES.length()) {
2617                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2618                 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
2619             }
2620         }
2621 
2622         assertShiftArraysEquals(r, a, b, Short512VectorTests::LSHR_unary);
2623     }
2624 
2625     @Test(dataProvider = "shortBinaryOpMaskProvider")
2626     static void LSHRShort512VectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2627                                           IntFunction<boolean[]> fm) {
2628         short[] a = fa.apply(SPECIES.length());
2629         short[] b = fb.apply(SPECIES.length());
2630         short[] r = fr.apply(SPECIES.length());
2631         boolean[] mask = fm.apply(SPECIES.length());
2632         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2633 
2634         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2635             for (int i = 0; i < a.length; i += SPECIES.length()) {
2636                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2637                 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
2638             }
2639         }
2640 
2641         assertShiftArraysEquals(r, a, b, mask, Short512VectorTests::LSHR_unary);
2642     }
2643 
2644     static short ASHR_unary(short a, short b) {
2645         return (short)((a >> (b & 15)));
2646     }
2647 
2648     @Test(dataProvider = "shortBinaryOpProvider")
2649     static void ASHRShort512VectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2650         short[] a = fa.apply(SPECIES.length());
2651         short[] b = fb.apply(SPECIES.length());
2652         short[] r = fr.apply(SPECIES.length());
2653 
2654         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2655             for (int i = 0; i < a.length; i += SPECIES.length()) {
2656                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2657                 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
2658             }
2659         }
2660 
2661         assertShiftArraysEquals(r, a, b, Short512VectorTests::ASHR_unary);
2662     }
2663 
2664     @Test(dataProvider = "shortBinaryOpMaskProvider")
2665     static void ASHRShort512VectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2666                                           IntFunction<boolean[]> fm) {
2667         short[] a = fa.apply(SPECIES.length());
2668         short[] b = fb.apply(SPECIES.length());
2669         short[] r = fr.apply(SPECIES.length());
2670         boolean[] mask = fm.apply(SPECIES.length());
2671         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2672 
2673         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2674             for (int i = 0; i < a.length; i += SPECIES.length()) {
2675                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2676                 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
2677             }
2678         }
2679 
2680         assertShiftArraysEquals(r, a, b, mask, Short512VectorTests::ASHR_unary);
2681     }
2682 
2683     static short ROR(short a, short b) {
2684         return (short)(ROR_scalar(a,b));
2685     }
2686 
2687     @Test(dataProvider = "shortBinaryOpProvider")
2688     static void RORShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2689         short[] a = fa.apply(SPECIES.length());
2690         short[] b = fb.apply(SPECIES.length());
2691         short[] r = fr.apply(SPECIES.length());
2692 
2693         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2694             for (int i = 0; i < a.length; i += SPECIES.length()) {
2695                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2696                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2697                 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
2698             }
2699         }
2700 
2701         assertArraysEquals(r, a, b, Short512VectorTests::ROR);
2702     }
2703 
2704     @Test(dataProvider = "shortBinaryOpMaskProvider")
2705     static void RORShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2706                                           IntFunction<boolean[]> fm) {
2707         short[] a = fa.apply(SPECIES.length());
2708         short[] b = fb.apply(SPECIES.length());
2709         short[] r = fr.apply(SPECIES.length());
2710         boolean[] mask = fm.apply(SPECIES.length());
2711         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2712 
2713         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2714             for (int i = 0; i < a.length; i += SPECIES.length()) {
2715                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2716                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2717                 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
2718             }
2719         }
2720 
2721         assertArraysEquals(r, a, b, mask, Short512VectorTests::ROR);
2722     }
2723 
2724     static short ROL(short a, short b) {
2725         return (short)(ROL_scalar(a,b));
2726     }
2727 
2728     @Test(dataProvider = "shortBinaryOpProvider")
2729     static void ROLShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2730         short[] a = fa.apply(SPECIES.length());
2731         short[] b = fb.apply(SPECIES.length());
2732         short[] r = fr.apply(SPECIES.length());
2733 
2734         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2735             for (int i = 0; i < a.length; i += SPECIES.length()) {
2736                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2737                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2738                 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
2739             }
2740         }
2741 
2742         assertArraysEquals(r, a, b, Short512VectorTests::ROL);
2743     }
2744 
2745     @Test(dataProvider = "shortBinaryOpMaskProvider")
2746     static void ROLShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2747                                           IntFunction<boolean[]> fm) {
2748         short[] a = fa.apply(SPECIES.length());
2749         short[] b = fb.apply(SPECIES.length());
2750         short[] r = fr.apply(SPECIES.length());
2751         boolean[] mask = fm.apply(SPECIES.length());
2752         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2753 
2754         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2755             for (int i = 0; i < a.length; i += SPECIES.length()) {
2756                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2757                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2758                 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
2759             }
2760         }
2761 
2762         assertArraysEquals(r, a, b, mask, Short512VectorTests::ROL);
2763     }
2764 
2765     static short ROR_unary(short a, short b) {
2766         return (short)(ROR_scalar(a, b));
2767     }
2768 
2769     @Test(dataProvider = "shortBinaryOpProvider")
2770     static void RORShort512VectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2771         short[] a = fa.apply(SPECIES.length());
2772         short[] b = fb.apply(SPECIES.length());
2773         short[] r = fr.apply(SPECIES.length());
2774 
2775         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2776             for (int i = 0; i < a.length; i += SPECIES.length()) {
2777                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2778                 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
2779             }
2780         }
2781 
2782         assertShiftArraysEquals(r, a, b, Short512VectorTests::ROR_unary);
2783     }
2784 
2785     @Test(dataProvider = "shortBinaryOpMaskProvider")
2786     static void RORShort512VectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2787                                           IntFunction<boolean[]> fm) {
2788         short[] a = fa.apply(SPECIES.length());
2789         short[] b = fb.apply(SPECIES.length());
2790         short[] r = fr.apply(SPECIES.length());
2791         boolean[] mask = fm.apply(SPECIES.length());
2792         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2793 
2794         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2795             for (int i = 0; i < a.length; i += SPECIES.length()) {
2796                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2797                 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
2798             }
2799         }
2800 
2801         assertShiftArraysEquals(r, a, b, mask, Short512VectorTests::ROR_unary);
2802     }
2803 
2804     static short ROL_unary(short a, short b) {
2805         return (short)(ROL_scalar(a, b));
2806     }
2807 
2808     @Test(dataProvider = "shortBinaryOpProvider")
2809     static void ROLShort512VectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2810         short[] a = fa.apply(SPECIES.length());
2811         short[] b = fb.apply(SPECIES.length());
2812         short[] r = fr.apply(SPECIES.length());
2813 
2814         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2815             for (int i = 0; i < a.length; i += SPECIES.length()) {
2816                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2817                 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
2818             }
2819         }
2820 
2821         assertShiftArraysEquals(r, a, b, Short512VectorTests::ROL_unary);
2822     }
2823 
2824     @Test(dataProvider = "shortBinaryOpMaskProvider")
2825     static void ROLShort512VectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2826                                           IntFunction<boolean[]> fm) {
2827         short[] a = fa.apply(SPECIES.length());
2828         short[] b = fb.apply(SPECIES.length());
2829         short[] r = fr.apply(SPECIES.length());
2830         boolean[] mask = fm.apply(SPECIES.length());
2831         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2832 
2833         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2834             for (int i = 0; i < a.length; i += SPECIES.length()) {
2835                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2836                 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
2837             }
2838         }
2839 
2840         assertShiftArraysEquals(r, a, b, mask, Short512VectorTests::ROL_unary);
2841     }
2842     static short LSHR_binary_const(short a) {
2843         return (short)(((a & 0xFFFF) >>> CONST_SHIFT));
2844     }
2845 
2846     @Test(dataProvider = "shortUnaryOpProvider")
2847     static void LSHRShort512VectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2848         short[] a = fa.apply(SPECIES.length());
2849         short[] r = fr.apply(SPECIES.length());
2850 
2851         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2852             for (int i = 0; i < a.length; i += SPECIES.length()) {
2853                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2854                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i);
2855             }
2856         }
2857 
2858         assertShiftConstEquals(r, a, Short512VectorTests::LSHR_binary_const);
2859     }
2860 
2861     @Test(dataProvider = "shortUnaryOpMaskProvider")
2862     static void LSHRShort512VectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2863                                           IntFunction<boolean[]> fm) {
2864         short[] a = fa.apply(SPECIES.length());
2865         short[] r = fr.apply(SPECIES.length());
2866         boolean[] mask = fm.apply(SPECIES.length());
2867         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2868 
2869         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2870             for (int i = 0; i < a.length; i += SPECIES.length()) {
2871                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2872                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i);
2873             }
2874         }
2875 
2876         assertShiftConstEquals(r, a, mask, Short512VectorTests::LSHR_binary_const);
2877     }
2878 
2879     static short LSHL_binary_const(short a) {
2880         return (short)((a << CONST_SHIFT));
2881     }
2882 
2883     @Test(dataProvider = "shortUnaryOpProvider")
2884     static void LSHLShort512VectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2885         short[] a = fa.apply(SPECIES.length());
2886         short[] r = fr.apply(SPECIES.length());
2887 
2888         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2889             for (int i = 0; i < a.length; i += SPECIES.length()) {
2890                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2891                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i);
2892             }
2893         }
2894 
2895         assertShiftConstEquals(r, a, Short512VectorTests::LSHL_binary_const);
2896     }
2897 
2898     @Test(dataProvider = "shortUnaryOpMaskProvider")
2899     static void LSHLShort512VectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2900                                           IntFunction<boolean[]> fm) {
2901         short[] a = fa.apply(SPECIES.length());
2902         short[] r = fr.apply(SPECIES.length());
2903         boolean[] mask = fm.apply(SPECIES.length());
2904         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2905 
2906         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2907             for (int i = 0; i < a.length; i += SPECIES.length()) {
2908                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2909                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i);
2910             }
2911         }
2912 
2913         assertShiftConstEquals(r, a, mask, Short512VectorTests::LSHL_binary_const);
2914     }
2915 
2916     static short ASHR_binary_const(short a) {
2917         return (short)((a >> CONST_SHIFT));
2918     }
2919 
2920     @Test(dataProvider = "shortUnaryOpProvider")
2921     static void ASHRShort512VectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2922         short[] a = fa.apply(SPECIES.length());
2923         short[] r = fr.apply(SPECIES.length());
2924 
2925         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2926             for (int i = 0; i < a.length; i += SPECIES.length()) {
2927                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2928                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i);
2929             }
2930         }
2931 
2932         assertShiftConstEquals(r, a, Short512VectorTests::ASHR_binary_const);
2933     }
2934 
2935     @Test(dataProvider = "shortUnaryOpMaskProvider")
2936     static void ASHRShort512VectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2937                                           IntFunction<boolean[]> fm) {
2938         short[] a = fa.apply(SPECIES.length());
2939         short[] r = fr.apply(SPECIES.length());
2940         boolean[] mask = fm.apply(SPECIES.length());
2941         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2942 
2943         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2944             for (int i = 0; i < a.length; i += SPECIES.length()) {
2945                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2946                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i);
2947             }
2948         }
2949 
2950         assertShiftConstEquals(r, a, mask, Short512VectorTests::ASHR_binary_const);
2951     }
2952 
2953     static short ROR_binary_const(short a) {
2954         return (short)(ROR_scalar(a, CONST_SHIFT));
2955     }
2956 
2957     @Test(dataProvider = "shortUnaryOpProvider")
2958     static void RORShort512VectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2959         short[] a = fa.apply(SPECIES.length());
2960         short[] r = fr.apply(SPECIES.length());
2961 
2962         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2963             for (int i = 0; i < a.length; i += SPECIES.length()) {
2964                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2965                 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i);
2966             }
2967         }
2968 
2969         assertShiftConstEquals(r, a, Short512VectorTests::ROR_binary_const);
2970     }
2971 
2972     @Test(dataProvider = "shortUnaryOpMaskProvider")
2973     static void RORShort512VectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2974                                           IntFunction<boolean[]> fm) {
2975         short[] a = fa.apply(SPECIES.length());
2976         short[] r = fr.apply(SPECIES.length());
2977         boolean[] mask = fm.apply(SPECIES.length());
2978         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2979 
2980         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2981             for (int i = 0; i < a.length; i += SPECIES.length()) {
2982                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2983                 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i);
2984             }
2985         }
2986 
2987         assertShiftConstEquals(r, a, mask, Short512VectorTests::ROR_binary_const);
2988     }
2989 
2990     static short ROL_binary_const(short a) {
2991         return (short)(ROL_scalar(a, CONST_SHIFT));
2992     }
2993 
2994     @Test(dataProvider = "shortUnaryOpProvider")
2995     static void ROLShort512VectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2996         short[] a = fa.apply(SPECIES.length());
2997         short[] r = fr.apply(SPECIES.length());
2998 
2999         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3000             for (int i = 0; i < a.length; i += SPECIES.length()) {
3001                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3002                 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i);
3003             }
3004         }
3005 
3006         assertShiftConstEquals(r, a, Short512VectorTests::ROL_binary_const);
3007     }
3008 
3009     @Test(dataProvider = "shortUnaryOpMaskProvider")
3010     static void ROLShort512VectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
3011                                           IntFunction<boolean[]> fm) {
3012         short[] a = fa.apply(SPECIES.length());
3013         short[] r = fr.apply(SPECIES.length());
3014         boolean[] mask = fm.apply(SPECIES.length());
3015         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3016 
3017         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3018             for (int i = 0; i < a.length; i += SPECIES.length()) {
3019                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3020                 av.lanewise(VectorOperators.ROL, CONST_SHIFT, vmask).intoArray(r, i);
3021             }
3022         }
3023 
3024         assertShiftConstEquals(r, a, mask, Short512VectorTests::ROL_binary_const);
3025     }
3026 
3027 
3028     @Test(dataProvider = "shortUnaryOpProvider")
3029     static void MINShort512VectorTestsWithMemOp(IntFunction<short[]> fa) {
3030         short[] a = fa.apply(SPECIES.length());
3031         short[] r = fr.apply(SPECIES.length());
3032 
3033         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3034             for (int i = 0; i < a.length; i += SPECIES.length()) {
3035                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3036                 av.lanewise(VectorOperators.MIN, bcast_vec).intoArray(r, i);
3037             }
3038         }
3039 
3040         assertArraysEquals(r, a, (short)10, Short512VectorTests::MIN);
3041     }
3042 
3043     @Test(dataProvider = "shortUnaryOpProvider")
3044     static void minShort512VectorTestsWithMemOp(IntFunction<short[]> fa) {
3045         short[] a = fa.apply(SPECIES.length());
3046         short[] r = fr.apply(SPECIES.length());
3047 
3048         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3049             for (int i = 0; i < a.length; i += SPECIES.length()) {
3050                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3051                 av.min(bcast_vec).intoArray(r, i);
3052             }
3053         }
3054 
3055         assertArraysEquals(r, a, (short)10, Short512VectorTests::min);
3056     }
3057 
3058     @Test(dataProvider = "shortUnaryOpMaskProvider")
3059     static void MINShort512VectorTestsMaskedWithMemOp(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3060         short[] a = fa.apply(SPECIES.length());
3061         short[] r = fr.apply(SPECIES.length());
3062         boolean[] mask = fm.apply(SPECIES.length());
3063         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3064 
3065         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3066             for (int i = 0; i < a.length; i += SPECIES.length()) {
3067                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3068                 av.lanewise(VectorOperators.MIN, bcast_vec, vmask).intoArray(r, i);
3069             }
3070         }
3071 
3072         assertArraysEquals(r, a, (short)10, mask, Short512VectorTests::MIN);
3073     }
3074 
3075     @Test(dataProvider = "shortUnaryOpProvider")
3076     static void MAXShort512VectorTestsWithMemOp(IntFunction<short[]> fa) {
3077         short[] a = fa.apply(SPECIES.length());
3078         short[] r = fr.apply(SPECIES.length());
3079 
3080         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3081             for (int i = 0; i < a.length; i += SPECIES.length()) {
3082                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3083                 av.lanewise(VectorOperators.MAX, bcast_vec).intoArray(r, i);
3084             }
3085         }
3086 
3087         assertArraysEquals(r, a, (short)10, Short512VectorTests::MAX);
3088     }
3089 
3090     @Test(dataProvider = "shortUnaryOpProvider")
3091     static void maxShort512VectorTestsWithMemOp(IntFunction<short[]> fa) {
3092         short[] a = fa.apply(SPECIES.length());
3093         short[] r = fr.apply(SPECIES.length());
3094 
3095         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3096             for (int i = 0; i < a.length; i += SPECIES.length()) {
3097                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3098                 av.max(bcast_vec).intoArray(r, i);
3099             }
3100         }
3101 
3102         assertArraysEquals(r, a, (short)10, Short512VectorTests::max);
3103     }
3104 
3105     @Test(dataProvider = "shortUnaryOpMaskProvider")
3106     static void MAXShort512VectorTestsMaskedWithMemOp(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3107         short[] a = fa.apply(SPECIES.length());
3108         short[] r = fr.apply(SPECIES.length());
3109         boolean[] mask = fm.apply(SPECIES.length());
3110         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3111 
3112         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3113             for (int i = 0; i < a.length; i += SPECIES.length()) {
3114                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3115                 av.lanewise(VectorOperators.MAX, bcast_vec, vmask).intoArray(r, i);
3116             }
3117         }
3118 
3119         assertArraysEquals(r, a, (short)10, mask, Short512VectorTests::MAX);
3120     }
3121 
3122     static short MIN(short a, short b) {
3123         return (short)(Math.min(a, b));
3124     }
3125 
3126     @Test(dataProvider = "shortBinaryOpProvider")
3127     static void MINShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3128         short[] a = fa.apply(SPECIES.length());
3129         short[] b = fb.apply(SPECIES.length());
3130         short[] r = fr.apply(SPECIES.length());
3131 
3132         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3133             for (int i = 0; i < a.length; i += SPECIES.length()) {
3134                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3135                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3136                 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
3137             }
3138         }
3139 
3140         assertArraysEquals(r, a, b, Short512VectorTests::MIN);
3141     }
3142 
3143     static short min(short a, short b) {
3144         return (short)(Math.min(a, b));
3145     }
3146 
3147     @Test(dataProvider = "shortBinaryOpProvider")
3148     static void minShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3149         short[] a = fa.apply(SPECIES.length());
3150         short[] b = fb.apply(SPECIES.length());
3151         short[] r = fr.apply(SPECIES.length());
3152 
3153         for (int i = 0; i < a.length; i += SPECIES.length()) {
3154             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3155             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3156             av.min(bv).intoArray(r, i);
3157         }
3158 
3159         assertArraysEquals(r, a, b, Short512VectorTests::min);
3160     }
3161 
3162     static short MAX(short a, short b) {
3163         return (short)(Math.max(a, b));
3164     }
3165 
3166     @Test(dataProvider = "shortBinaryOpProvider")
3167     static void MAXShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3168         short[] a = fa.apply(SPECIES.length());
3169         short[] b = fb.apply(SPECIES.length());
3170         short[] r = fr.apply(SPECIES.length());
3171 
3172         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3173             for (int i = 0; i < a.length; i += SPECIES.length()) {
3174                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3175                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3176                 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
3177             }
3178         }
3179 
3180         assertArraysEquals(r, a, b, Short512VectorTests::MAX);
3181     }
3182 
3183     static short max(short a, short b) {
3184         return (short)(Math.max(a, b));
3185     }
3186 
3187     @Test(dataProvider = "shortBinaryOpProvider")
3188     static void maxShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3189         short[] a = fa.apply(SPECIES.length());
3190         short[] b = fb.apply(SPECIES.length());
3191         short[] r = fr.apply(SPECIES.length());
3192 
3193         for (int i = 0; i < a.length; i += SPECIES.length()) {
3194             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3195             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3196             av.max(bv).intoArray(r, i);
3197         }
3198 
3199         assertArraysEquals(r, a, b, Short512VectorTests::max);
3200     }
3201 
3202     static short UMIN(short a, short b) {
3203         return (short)(VectorMath.minUnsigned(a, b));
3204     }
3205 
3206     @Test(dataProvider = "shortBinaryOpProvider")
3207     static void UMINShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3208         short[] a = fa.apply(SPECIES.length());
3209         short[] b = fb.apply(SPECIES.length());
3210         short[] r = fr.apply(SPECIES.length());
3211 
3212         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3213             for (int i = 0; i < a.length; i += SPECIES.length()) {
3214                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3215                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3216                 av.lanewise(VectorOperators.UMIN, bv).intoArray(r, i);
3217             }
3218         }
3219 
3220         assertArraysEquals(r, a, b, Short512VectorTests::UMIN);
3221     }
3222 
3223     @Test(dataProvider = "shortBinaryOpMaskProvider")
3224     static void UMINShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3225                                           IntFunction<boolean[]> fm) {
3226         short[] a = fa.apply(SPECIES.length());
3227         short[] b = fb.apply(SPECIES.length());
3228         short[] r = fr.apply(SPECIES.length());
3229         boolean[] mask = fm.apply(SPECIES.length());
3230         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3231 
3232         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3233             for (int i = 0; i < a.length; i += SPECIES.length()) {
3234                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3235                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3236                 av.lanewise(VectorOperators.UMIN, bv, vmask).intoArray(r, i);
3237             }
3238         }
3239 
3240         assertArraysEquals(r, a, b, mask, Short512VectorTests::UMIN);
3241     }
3242 
3243     static short UMAX(short a, short b) {
3244         return (short)(VectorMath.maxUnsigned(a, b));
3245     }
3246 
3247     @Test(dataProvider = "shortBinaryOpProvider")
3248     static void UMAXShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3249         short[] a = fa.apply(SPECIES.length());
3250         short[] b = fb.apply(SPECIES.length());
3251         short[] r = fr.apply(SPECIES.length());
3252 
3253         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3254             for (int i = 0; i < a.length; i += SPECIES.length()) {
3255                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3256                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3257                 av.lanewise(VectorOperators.UMAX, bv).intoArray(r, i);
3258             }
3259         }
3260 
3261         assertArraysEquals(r, a, b, Short512VectorTests::UMAX);
3262     }
3263 
3264     @Test(dataProvider = "shortBinaryOpMaskProvider")
3265     static void UMAXShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3266                                           IntFunction<boolean[]> fm) {
3267         short[] a = fa.apply(SPECIES.length());
3268         short[] b = fb.apply(SPECIES.length());
3269         short[] r = fr.apply(SPECIES.length());
3270         boolean[] mask = fm.apply(SPECIES.length());
3271         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3272 
3273         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3274             for (int i = 0; i < a.length; i += SPECIES.length()) {
3275                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3276                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3277                 av.lanewise(VectorOperators.UMAX, bv, vmask).intoArray(r, i);
3278             }
3279         }
3280 
3281         assertArraysEquals(r, a, b, mask, Short512VectorTests::UMAX);
3282     }
3283 
3284     static short SADD(short a, short b) {
3285         return (short)(VectorMath.addSaturating(a, b));
3286     }
3287 
3288     @Test(dataProvider = "shortSaturatingBinaryOpProvider")
3289     static void SADDShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3290         short[] a = fa.apply(SPECIES.length());
3291         short[] b = fb.apply(SPECIES.length());
3292         short[] r = fr.apply(SPECIES.length());
3293 
3294         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3295             for (int i = 0; i < a.length; i += SPECIES.length()) {
3296                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3297                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3298                 av.lanewise(VectorOperators.SADD, bv).intoArray(r, i);
3299             }
3300         }
3301 
3302         assertArraysEquals(r, a, b, Short512VectorTests::SADD);
3303     }
3304 
3305     @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider")
3306     static void SADDShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3307                                           IntFunction<boolean[]> fm) {
3308         short[] a = fa.apply(SPECIES.length());
3309         short[] b = fb.apply(SPECIES.length());
3310         short[] r = fr.apply(SPECIES.length());
3311         boolean[] mask = fm.apply(SPECIES.length());
3312         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3313 
3314         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3315             for (int i = 0; i < a.length; i += SPECIES.length()) {
3316                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3317                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3318                 av.lanewise(VectorOperators.SADD, bv, vmask).intoArray(r, i);
3319             }
3320         }
3321 
3322         assertArraysEquals(r, a, b, mask, Short512VectorTests::SADD);
3323     }
3324 
3325     static short SSUB(short a, short b) {
3326         return (short)(VectorMath.subSaturating(a, b));
3327     }
3328 
3329     @Test(dataProvider = "shortSaturatingBinaryOpProvider")
3330     static void SSUBShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3331         short[] a = fa.apply(SPECIES.length());
3332         short[] b = fb.apply(SPECIES.length());
3333         short[] r = fr.apply(SPECIES.length());
3334 
3335         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3336             for (int i = 0; i < a.length; i += SPECIES.length()) {
3337                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3338                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3339                 av.lanewise(VectorOperators.SSUB, bv).intoArray(r, i);
3340             }
3341         }
3342 
3343         assertArraysEquals(r, a, b, Short512VectorTests::SSUB);
3344     }
3345 
3346     @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider")
3347     static void SSUBShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3348                                           IntFunction<boolean[]> fm) {
3349         short[] a = fa.apply(SPECIES.length());
3350         short[] b = fb.apply(SPECIES.length());
3351         short[] r = fr.apply(SPECIES.length());
3352         boolean[] mask = fm.apply(SPECIES.length());
3353         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3354 
3355         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3356             for (int i = 0; i < a.length; i += SPECIES.length()) {
3357                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3358                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3359                 av.lanewise(VectorOperators.SSUB, bv, vmask).intoArray(r, i);
3360             }
3361         }
3362 
3363         assertArraysEquals(r, a, b, mask, Short512VectorTests::SSUB);
3364     }
3365 
3366     static short SUADD(short a, short b) {
3367         return (short)(VectorMath.addSaturatingUnsigned(a, b));
3368     }
3369 
3370     @Test(dataProvider = "shortSaturatingBinaryOpProvider")
3371     static void SUADDShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3372         short[] a = fa.apply(SPECIES.length());
3373         short[] b = fb.apply(SPECIES.length());
3374         short[] r = fr.apply(SPECIES.length());
3375 
3376         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3377             for (int i = 0; i < a.length; i += SPECIES.length()) {
3378                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3379                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3380                 av.lanewise(VectorOperators.SUADD, bv).intoArray(r, i);
3381             }
3382         }
3383 
3384         assertArraysEquals(r, a, b, Short512VectorTests::SUADD);
3385     }
3386 
3387     @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider")
3388     static void SUADDShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3389                                           IntFunction<boolean[]> fm) {
3390         short[] a = fa.apply(SPECIES.length());
3391         short[] b = fb.apply(SPECIES.length());
3392         short[] r = fr.apply(SPECIES.length());
3393         boolean[] mask = fm.apply(SPECIES.length());
3394         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3395 
3396         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3397             for (int i = 0; i < a.length; i += SPECIES.length()) {
3398                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3399                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3400                 av.lanewise(VectorOperators.SUADD, bv, vmask).intoArray(r, i);
3401             }
3402         }
3403 
3404         assertArraysEquals(r, a, b, mask, Short512VectorTests::SUADD);
3405     }
3406 
3407     static short SUSUB(short a, short b) {
3408         return (short)(VectorMath.subSaturatingUnsigned(a, b));
3409     }
3410 
3411     @Test(dataProvider = "shortSaturatingBinaryOpProvider")
3412     static void SUSUBShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3413         short[] a = fa.apply(SPECIES.length());
3414         short[] b = fb.apply(SPECIES.length());
3415         short[] r = fr.apply(SPECIES.length());
3416 
3417         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3418             for (int i = 0; i < a.length; i += SPECIES.length()) {
3419                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3420                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3421                 av.lanewise(VectorOperators.SUSUB, bv).intoArray(r, i);
3422             }
3423         }
3424 
3425         assertArraysEquals(r, a, b, Short512VectorTests::SUSUB);
3426     }
3427 
3428     @Test(dataProvider = "shortSaturatingBinaryOpMaskProvider")
3429     static void SUSUBShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3430                                           IntFunction<boolean[]> fm) {
3431         short[] a = fa.apply(SPECIES.length());
3432         short[] b = fb.apply(SPECIES.length());
3433         short[] r = fr.apply(SPECIES.length());
3434         boolean[] mask = fm.apply(SPECIES.length());
3435         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3436 
3437         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3438             for (int i = 0; i < a.length; i += SPECIES.length()) {
3439                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3440                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3441                 av.lanewise(VectorOperators.SUSUB, bv, vmask).intoArray(r, i);
3442             }
3443         }
3444 
3445         assertArraysEquals(r, a, b, mask, Short512VectorTests::SUSUB);
3446     }
3447 
3448     @Test(dataProvider = "shortBinaryOpProvider")
3449     static void MINShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3450         short[] a = fa.apply(SPECIES.length());
3451         short[] b = fb.apply(SPECIES.length());
3452         short[] r = fr.apply(SPECIES.length());
3453 
3454         for (int i = 0; i < a.length; i += SPECIES.length()) {
3455             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3456             av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
3457         }
3458 
3459         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::MIN);
3460     }
3461 
3462     @Test(dataProvider = "shortBinaryOpProvider")
3463     static void minShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3464         short[] a = fa.apply(SPECIES.length());
3465         short[] b = fb.apply(SPECIES.length());
3466         short[] r = fr.apply(SPECIES.length());
3467 
3468         for (int i = 0; i < a.length; i += SPECIES.length()) {
3469             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3470             av.min(b[i]).intoArray(r, i);
3471         }
3472 
3473         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::min);
3474     }
3475 
3476     @Test(dataProvider = "shortBinaryOpProvider")
3477     static void MAXShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3478         short[] a = fa.apply(SPECIES.length());
3479         short[] b = fb.apply(SPECIES.length());
3480         short[] r = fr.apply(SPECIES.length());
3481 
3482         for (int i = 0; i < a.length; i += SPECIES.length()) {
3483             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3484             av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
3485         }
3486 
3487         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::MAX);
3488     }
3489 
3490     @Test(dataProvider = "shortBinaryOpProvider")
3491     static void maxShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3492         short[] a = fa.apply(SPECIES.length());
3493         short[] b = fb.apply(SPECIES.length());
3494         short[] r = fr.apply(SPECIES.length());
3495 
3496         for (int i = 0; i < a.length; i += SPECIES.length()) {
3497             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3498             av.max(b[i]).intoArray(r, i);
3499         }
3500 
3501         assertBroadcastArraysEquals(r, a, b, Short512VectorTests::max);
3502     }
3503     @Test(dataProvider = "shortSaturatingBinaryOpAssocProvider")
3504     static void SUADDAssocShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
3505         short[] a = fa.apply(SPECIES.length());
3506         short[] b = fb.apply(SPECIES.length());
3507         short[] c = fc.apply(SPECIES.length());
3508         short[] rl = fr.apply(SPECIES.length());
3509         short[] rr = fr.apply(SPECIES.length());
3510 
3511         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3512             for (int i = 0; i < a.length; i += SPECIES.length()) {
3513                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3514                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3515                 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
3516                 av.lanewise(VectorOperators.SUADD, bv).lanewise(VectorOperators.SUADD, cv).intoArray(rl, i);
3517                 av.lanewise(VectorOperators.SUADD, bv.lanewise(VectorOperators.SUADD, cv)).intoArray(rr, i);
3518             }
3519         }
3520 
3521         assertArraysEqualsAssociative(rl, rr, a, b, c, Short512VectorTests::SUADD);
3522     }
3523 
3524     @Test(dataProvider = "shortSaturatingBinaryOpAssocMaskProvider")
3525     static void SUADDAssocShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3526                                                      IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
3527         short[] a = fa.apply(SPECIES.length());
3528         short[] b = fb.apply(SPECIES.length());
3529         short[] c = fc.apply(SPECIES.length());
3530         boolean[] mask = fm.apply(SPECIES.length());
3531         short[] rl = fr.apply(SPECIES.length());
3532         short[] rr = fr.apply(SPECIES.length());
3533 
3534         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3535 
3536         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3537             for (int i = 0; i < a.length; i += SPECIES.length()) {
3538                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3539                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3540                 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
3541                 av.lanewise(VectorOperators.SUADD, bv, vmask).lanewise(VectorOperators.SUADD, cv, vmask).intoArray(rl, i);
3542                 av.lanewise(VectorOperators.SUADD, bv.lanewise(VectorOperators.SUADD, cv, vmask), vmask).intoArray(rr, i);
3543             }
3544         }
3545 
3546         assertArraysEqualsAssociative(rl, rr, a, b, c, mask, Short512VectorTests::SUADD);
3547     }
3548 
3549     static short ANDReduce(short[] a, int idx) {
3550         short res = -1;
3551         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3552             res &= a[i];
3553         }
3554 
3555         return res;
3556     }
3557 
3558     static short ANDReduceAll(short[] a) {
3559         short res = -1;
3560         for (int i = 0; i < a.length; i += SPECIES.length()) {
3561             res &= ANDReduce(a, i);
3562         }
3563 
3564         return res;
3565     }
3566 
3567     @Test(dataProvider = "shortUnaryOpProvider")
3568     static void ANDReduceShort512VectorTests(IntFunction<short[]> fa) {
3569         short[] a = fa.apply(SPECIES.length());
3570         short[] r = fr.apply(SPECIES.length());
3571         short ra = -1;
3572 
3573         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3574             for (int i = 0; i < a.length; i += SPECIES.length()) {
3575                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3576                 r[i] = av.reduceLanes(VectorOperators.AND);
3577             }
3578         }
3579 
3580         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3581             ra = -1;
3582             for (int i = 0; i < a.length; i += SPECIES.length()) {
3583                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3584                 ra &= av.reduceLanes(VectorOperators.AND);
3585             }
3586         }
3587 
3588         assertReductionArraysEquals(r, ra, a,
3589                 Short512VectorTests::ANDReduce, Short512VectorTests::ANDReduceAll);
3590     }
3591 
3592     static short ANDReduceMasked(short[] a, int idx, boolean[] mask) {
3593         short res = -1;
3594         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3595             if (mask[i % SPECIES.length()])
3596                 res &= a[i];
3597         }
3598 
3599         return res;
3600     }
3601 
3602     static short ANDReduceAllMasked(short[] a, boolean[] mask) {
3603         short res = -1;
3604         for (int i = 0; i < a.length; i += SPECIES.length()) {
3605             res &= ANDReduceMasked(a, i, mask);
3606         }
3607 
3608         return res;
3609     }
3610 
3611     @Test(dataProvider = "shortUnaryOpMaskProvider")
3612     static void ANDReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3613         short[] a = fa.apply(SPECIES.length());
3614         short[] r = fr.apply(SPECIES.length());
3615         boolean[] mask = fm.apply(SPECIES.length());
3616         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3617         short ra = -1;
3618 
3619         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3620             for (int i = 0; i < a.length; i += SPECIES.length()) {
3621                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3622                 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
3623             }
3624         }
3625 
3626         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3627             ra = -1;
3628             for (int i = 0; i < a.length; i += SPECIES.length()) {
3629                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3630                 ra &= av.reduceLanes(VectorOperators.AND, vmask);
3631             }
3632         }
3633 
3634         assertReductionArraysEqualsMasked(r, ra, a, mask,
3635                 Short512VectorTests::ANDReduceMasked, Short512VectorTests::ANDReduceAllMasked);
3636     }
3637 
3638     static short ORReduce(short[] a, int idx) {
3639         short res = 0;
3640         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3641             res |= a[i];
3642         }
3643 
3644         return res;
3645     }
3646 
3647     static short ORReduceAll(short[] a) {
3648         short res = 0;
3649         for (int i = 0; i < a.length; i += SPECIES.length()) {
3650             res |= ORReduce(a, i);
3651         }
3652 
3653         return res;
3654     }
3655 
3656     @Test(dataProvider = "shortUnaryOpProvider")
3657     static void ORReduceShort512VectorTests(IntFunction<short[]> fa) {
3658         short[] a = fa.apply(SPECIES.length());
3659         short[] r = fr.apply(SPECIES.length());
3660         short ra = 0;
3661 
3662         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3663             for (int i = 0; i < a.length; i += SPECIES.length()) {
3664                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3665                 r[i] = av.reduceLanes(VectorOperators.OR);
3666             }
3667         }
3668 
3669         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3670             ra = 0;
3671             for (int i = 0; i < a.length; i += SPECIES.length()) {
3672                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3673                 ra |= av.reduceLanes(VectorOperators.OR);
3674             }
3675         }
3676 
3677         assertReductionArraysEquals(r, ra, a,
3678                 Short512VectorTests::ORReduce, Short512VectorTests::ORReduceAll);
3679     }
3680 
3681     static short ORReduceMasked(short[] a, int idx, boolean[] mask) {
3682         short res = 0;
3683         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3684             if (mask[i % SPECIES.length()])
3685                 res |= a[i];
3686         }
3687 
3688         return res;
3689     }
3690 
3691     static short ORReduceAllMasked(short[] a, boolean[] mask) {
3692         short res = 0;
3693         for (int i = 0; i < a.length; i += SPECIES.length()) {
3694             res |= ORReduceMasked(a, i, mask);
3695         }
3696 
3697         return res;
3698     }
3699 
3700     @Test(dataProvider = "shortUnaryOpMaskProvider")
3701     static void ORReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3702         short[] a = fa.apply(SPECIES.length());
3703         short[] r = fr.apply(SPECIES.length());
3704         boolean[] mask = fm.apply(SPECIES.length());
3705         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3706         short ra = 0;
3707 
3708         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3709             for (int i = 0; i < a.length; i += SPECIES.length()) {
3710                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3711                 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
3712             }
3713         }
3714 
3715         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3716             ra = 0;
3717             for (int i = 0; i < a.length; i += SPECIES.length()) {
3718                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3719                 ra |= av.reduceLanes(VectorOperators.OR, vmask);
3720             }
3721         }
3722 
3723         assertReductionArraysEqualsMasked(r, ra, a, mask,
3724                 Short512VectorTests::ORReduceMasked, Short512VectorTests::ORReduceAllMasked);
3725     }
3726 
3727     static short XORReduce(short[] a, int idx) {
3728         short res = 0;
3729         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3730             res ^= a[i];
3731         }
3732 
3733         return res;
3734     }
3735 
3736     static short XORReduceAll(short[] a) {
3737         short res = 0;
3738         for (int i = 0; i < a.length; i += SPECIES.length()) {
3739             res ^= XORReduce(a, i);
3740         }
3741 
3742         return res;
3743     }
3744 
3745     @Test(dataProvider = "shortUnaryOpProvider")
3746     static void XORReduceShort512VectorTests(IntFunction<short[]> fa) {
3747         short[] a = fa.apply(SPECIES.length());
3748         short[] r = fr.apply(SPECIES.length());
3749         short ra = 0;
3750 
3751         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3752             for (int i = 0; i < a.length; i += SPECIES.length()) {
3753                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3754                 r[i] = av.reduceLanes(VectorOperators.XOR);
3755             }
3756         }
3757 
3758         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3759             ra = 0;
3760             for (int i = 0; i < a.length; i += SPECIES.length()) {
3761                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3762                 ra ^= av.reduceLanes(VectorOperators.XOR);
3763             }
3764         }
3765 
3766         assertReductionArraysEquals(r, ra, a,
3767                 Short512VectorTests::XORReduce, Short512VectorTests::XORReduceAll);
3768     }
3769 
3770     static short XORReduceMasked(short[] a, int idx, boolean[] mask) {
3771         short res = 0;
3772         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3773             if (mask[i % SPECIES.length()])
3774                 res ^= a[i];
3775         }
3776 
3777         return res;
3778     }
3779 
3780     static short XORReduceAllMasked(short[] a, boolean[] mask) {
3781         short res = 0;
3782         for (int i = 0; i < a.length; i += SPECIES.length()) {
3783             res ^= XORReduceMasked(a, i, mask);
3784         }
3785 
3786         return res;
3787     }
3788 
3789     @Test(dataProvider = "shortUnaryOpMaskProvider")
3790     static void XORReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3791         short[] a = fa.apply(SPECIES.length());
3792         short[] r = fr.apply(SPECIES.length());
3793         boolean[] mask = fm.apply(SPECIES.length());
3794         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3795         short ra = 0;
3796 
3797         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3798             for (int i = 0; i < a.length; i += SPECIES.length()) {
3799                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3800                 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
3801             }
3802         }
3803 
3804         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3805             ra = 0;
3806             for (int i = 0; i < a.length; i += SPECIES.length()) {
3807                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3808                 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
3809             }
3810         }
3811 
3812         assertReductionArraysEqualsMasked(r, ra, a, mask,
3813                 Short512VectorTests::XORReduceMasked, Short512VectorTests::XORReduceAllMasked);
3814     }
3815 
3816     static short ADDReduce(short[] a, int idx) {
3817         short res = 0;
3818         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3819             res += a[i];
3820         }
3821 
3822         return res;
3823     }
3824 
3825     static short ADDReduceAll(short[] a) {
3826         short res = 0;
3827         for (int i = 0; i < a.length; i += SPECIES.length()) {
3828             res += ADDReduce(a, i);
3829         }
3830 
3831         return res;
3832     }
3833 
3834     @Test(dataProvider = "shortUnaryOpProvider")
3835     static void ADDReduceShort512VectorTests(IntFunction<short[]> fa) {
3836         short[] a = fa.apply(SPECIES.length());
3837         short[] r = fr.apply(SPECIES.length());
3838         short ra = 0;
3839 
3840         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3841             for (int i = 0; i < a.length; i += SPECIES.length()) {
3842                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3843                 r[i] = av.reduceLanes(VectorOperators.ADD);
3844             }
3845         }
3846 
3847         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3848             ra = 0;
3849             for (int i = 0; i < a.length; i += SPECIES.length()) {
3850                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3851                 ra += av.reduceLanes(VectorOperators.ADD);
3852             }
3853         }
3854 
3855         assertReductionArraysEquals(r, ra, a,
3856                 Short512VectorTests::ADDReduce, Short512VectorTests::ADDReduceAll);
3857     }
3858 
3859     static short ADDReduceMasked(short[] a, int idx, boolean[] mask) {
3860         short res = 0;
3861         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3862             if (mask[i % SPECIES.length()])
3863                 res += a[i];
3864         }
3865 
3866         return res;
3867     }
3868 
3869     static short ADDReduceAllMasked(short[] a, boolean[] mask) {
3870         short res = 0;
3871         for (int i = 0; i < a.length; i += SPECIES.length()) {
3872             res += ADDReduceMasked(a, i, mask);
3873         }
3874 
3875         return res;
3876     }
3877 
3878     @Test(dataProvider = "shortUnaryOpMaskProvider")
3879     static void ADDReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3880         short[] a = fa.apply(SPECIES.length());
3881         short[] r = fr.apply(SPECIES.length());
3882         boolean[] mask = fm.apply(SPECIES.length());
3883         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3884         short ra = 0;
3885 
3886         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3887             for (int i = 0; i < a.length; i += SPECIES.length()) {
3888                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3889                 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
3890             }
3891         }
3892 
3893         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3894             ra = 0;
3895             for (int i = 0; i < a.length; i += SPECIES.length()) {
3896                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3897                 ra += av.reduceLanes(VectorOperators.ADD, vmask);
3898             }
3899         }
3900 
3901         assertReductionArraysEqualsMasked(r, ra, a, mask,
3902                 Short512VectorTests::ADDReduceMasked, Short512VectorTests::ADDReduceAllMasked);
3903     }
3904 
3905     static short MULReduce(short[] a, int idx) {
3906         short res = 1;
3907         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3908             res *= a[i];
3909         }
3910 
3911         return res;
3912     }
3913 
3914     static short MULReduceAll(short[] a) {
3915         short res = 1;
3916         for (int i = 0; i < a.length; i += SPECIES.length()) {
3917             res *= MULReduce(a, i);
3918         }
3919 
3920         return res;
3921     }
3922 
3923     @Test(dataProvider = "shortUnaryOpProvider")
3924     static void MULReduceShort512VectorTests(IntFunction<short[]> fa) {
3925         short[] a = fa.apply(SPECIES.length());
3926         short[] r = fr.apply(SPECIES.length());
3927         short ra = 1;
3928 
3929         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3930             for (int i = 0; i < a.length; i += SPECIES.length()) {
3931                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3932                 r[i] = av.reduceLanes(VectorOperators.MUL);
3933             }
3934         }
3935 
3936         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3937             ra = 1;
3938             for (int i = 0; i < a.length; i += SPECIES.length()) {
3939                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3940                 ra *= av.reduceLanes(VectorOperators.MUL);
3941             }
3942         }
3943 
3944         assertReductionArraysEquals(r, ra, a,
3945                 Short512VectorTests::MULReduce, Short512VectorTests::MULReduceAll);
3946     }
3947 
3948     static short MULReduceMasked(short[] a, int idx, boolean[] mask) {
3949         short res = 1;
3950         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3951             if (mask[i % SPECIES.length()])
3952                 res *= a[i];
3953         }
3954 
3955         return res;
3956     }
3957 
3958     static short MULReduceAllMasked(short[] a, boolean[] mask) {
3959         short res = 1;
3960         for (int i = 0; i < a.length; i += SPECIES.length()) {
3961             res *= MULReduceMasked(a, i, mask);
3962         }
3963 
3964         return res;
3965     }
3966 
3967     @Test(dataProvider = "shortUnaryOpMaskProvider")
3968     static void MULReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3969         short[] a = fa.apply(SPECIES.length());
3970         short[] r = fr.apply(SPECIES.length());
3971         boolean[] mask = fm.apply(SPECIES.length());
3972         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3973         short ra = 1;
3974 
3975         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3976             for (int i = 0; i < a.length; i += SPECIES.length()) {
3977                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3978                 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
3979             }
3980         }
3981 
3982         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3983             ra = 1;
3984             for (int i = 0; i < a.length; i += SPECIES.length()) {
3985                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3986                 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
3987             }
3988         }
3989 
3990         assertReductionArraysEqualsMasked(r, ra, a, mask,
3991                 Short512VectorTests::MULReduceMasked, Short512VectorTests::MULReduceAllMasked);
3992     }
3993 
3994     static short MINReduce(short[] a, int idx) {
3995         short res = Short.MAX_VALUE;
3996         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3997             res = (short) Math.min(res, a[i]);
3998         }
3999 
4000         return res;
4001     }
4002 
4003     static short MINReduceAll(short[] a) {
4004         short res = Short.MAX_VALUE;
4005         for (int i = 0; i < a.length; i += SPECIES.length()) {
4006             res = (short) Math.min(res, MINReduce(a, i));
4007         }
4008 
4009         return res;
4010     }
4011 
4012     @Test(dataProvider = "shortUnaryOpProvider")
4013     static void MINReduceShort512VectorTests(IntFunction<short[]> fa) {
4014         short[] a = fa.apply(SPECIES.length());
4015         short[] r = fr.apply(SPECIES.length());
4016         short ra = Short.MAX_VALUE;
4017 
4018         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4019             for (int i = 0; i < a.length; i += SPECIES.length()) {
4020                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4021                 r[i] = av.reduceLanes(VectorOperators.MIN);
4022             }
4023         }
4024 
4025         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4026             ra = Short.MAX_VALUE;
4027             for (int i = 0; i < a.length; i += SPECIES.length()) {
4028                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4029                 ra = (short) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
4030             }
4031         }
4032 
4033         assertReductionArraysEquals(r, ra, a,
4034                 Short512VectorTests::MINReduce, Short512VectorTests::MINReduceAll);
4035     }
4036 
4037     static short MINReduceMasked(short[] a, int idx, boolean[] mask) {
4038         short res = Short.MAX_VALUE;
4039         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4040             if (mask[i % SPECIES.length()])
4041                 res = (short) Math.min(res, a[i]);
4042         }
4043 
4044         return res;
4045     }
4046 
4047     static short MINReduceAllMasked(short[] a, boolean[] mask) {
4048         short res = Short.MAX_VALUE;
4049         for (int i = 0; i < a.length; i += SPECIES.length()) {
4050             res = (short) Math.min(res, MINReduceMasked(a, i, mask));
4051         }
4052 
4053         return res;
4054     }
4055 
4056     @Test(dataProvider = "shortUnaryOpMaskProvider")
4057     static void MINReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
4058         short[] a = fa.apply(SPECIES.length());
4059         short[] r = fr.apply(SPECIES.length());
4060         boolean[] mask = fm.apply(SPECIES.length());
4061         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4062         short ra = Short.MAX_VALUE;
4063 
4064         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4065             for (int i = 0; i < a.length; i += SPECIES.length()) {
4066                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4067                 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
4068             }
4069         }
4070 
4071         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4072             ra = Short.MAX_VALUE;
4073             for (int i = 0; i < a.length; i += SPECIES.length()) {
4074                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4075                 ra = (short) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
4076             }
4077         }
4078 
4079         assertReductionArraysEqualsMasked(r, ra, a, mask,
4080                 Short512VectorTests::MINReduceMasked, Short512VectorTests::MINReduceAllMasked);
4081     }
4082 
4083     static short MAXReduce(short[] a, int idx) {
4084         short res = Short.MIN_VALUE;
4085         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4086             res = (short) Math.max(res, a[i]);
4087         }
4088 
4089         return res;
4090     }
4091 
4092     static short MAXReduceAll(short[] a) {
4093         short res = Short.MIN_VALUE;
4094         for (int i = 0; i < a.length; i += SPECIES.length()) {
4095             res = (short) Math.max(res, MAXReduce(a, i));
4096         }
4097 
4098         return res;
4099     }
4100 
4101     @Test(dataProvider = "shortUnaryOpProvider")
4102     static void MAXReduceShort512VectorTests(IntFunction<short[]> fa) {
4103         short[] a = fa.apply(SPECIES.length());
4104         short[] r = fr.apply(SPECIES.length());
4105         short ra = Short.MIN_VALUE;
4106 
4107         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4108             for (int i = 0; i < a.length; i += SPECIES.length()) {
4109                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4110                 r[i] = av.reduceLanes(VectorOperators.MAX);
4111             }
4112         }
4113 
4114         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4115             ra = Short.MIN_VALUE;
4116             for (int i = 0; i < a.length; i += SPECIES.length()) {
4117                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4118                 ra = (short) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
4119             }
4120         }
4121 
4122         assertReductionArraysEquals(r, ra, a,
4123                 Short512VectorTests::MAXReduce, Short512VectorTests::MAXReduceAll);
4124     }
4125 
4126     static short MAXReduceMasked(short[] a, int idx, boolean[] mask) {
4127         short res = Short.MIN_VALUE;
4128         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4129             if (mask[i % SPECIES.length()])
4130                 res = (short) Math.max(res, a[i]);
4131         }
4132 
4133         return res;
4134     }
4135 
4136     static short MAXReduceAllMasked(short[] a, boolean[] mask) {
4137         short res = Short.MIN_VALUE;
4138         for (int i = 0; i < a.length; i += SPECIES.length()) {
4139             res = (short) Math.max(res, MAXReduceMasked(a, i, mask));
4140         }
4141 
4142         return res;
4143     }
4144 
4145     @Test(dataProvider = "shortUnaryOpMaskProvider")
4146     static void MAXReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
4147         short[] a = fa.apply(SPECIES.length());
4148         short[] r = fr.apply(SPECIES.length());
4149         boolean[] mask = fm.apply(SPECIES.length());
4150         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4151         short ra = Short.MIN_VALUE;
4152 
4153         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4154             for (int i = 0; i < a.length; i += SPECIES.length()) {
4155                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4156                 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
4157             }
4158         }
4159 
4160         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4161             ra = Short.MIN_VALUE;
4162             for (int i = 0; i < a.length; i += SPECIES.length()) {
4163                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4164                 ra = (short) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
4165             }
4166         }
4167 
4168         assertReductionArraysEqualsMasked(r, ra, a, mask,
4169                 Short512VectorTests::MAXReduceMasked, Short512VectorTests::MAXReduceAllMasked);
4170     }
4171 
4172     static short UMINReduce(short[] a, int idx) {
4173         short res = Short.MAX_VALUE;
4174         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4175             res = (short) VectorMath.minUnsigned(res, a[i]);
4176         }
4177 
4178         return res;
4179     }
4180 
4181     static short UMINReduceAll(short[] a) {
4182         short res = Short.MAX_VALUE;
4183         for (int i = 0; i < a.length; i += SPECIES.length()) {
4184             res = (short) VectorMath.minUnsigned(res, UMINReduce(a, i));
4185         }
4186 
4187         return res;
4188     }
4189 
4190     @Test(dataProvider = "shortUnaryOpProvider")
4191     static void UMINReduceShort512VectorTests(IntFunction<short[]> fa) {
4192         short[] a = fa.apply(SPECIES.length());
4193         short[] r = fr.apply(SPECIES.length());
4194         short ra = Short.MAX_VALUE;
4195 
4196         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4197             for (int i = 0; i < a.length; i += SPECIES.length()) {
4198                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4199                 r[i] = av.reduceLanes(VectorOperators.UMIN);
4200             }
4201         }
4202 
4203         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4204             ra = Short.MAX_VALUE;
4205             for (int i = 0; i < a.length; i += SPECIES.length()) {
4206                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4207                 ra = (short) VectorMath.minUnsigned(ra, av.reduceLanes(VectorOperators.UMIN));
4208             }
4209         }
4210 
4211         assertReductionArraysEquals(r, ra, a,
4212                 Short512VectorTests::UMINReduce, Short512VectorTests::UMINReduceAll);
4213     }
4214 
4215     static short UMINReduceMasked(short[] a, int idx, boolean[] mask) {
4216         short res = Short.MAX_VALUE;
4217         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4218             if (mask[i % SPECIES.length()])
4219                 res = (short) VectorMath.minUnsigned(res, a[i]);
4220         }
4221 
4222         return res;
4223     }
4224 
4225     static short UMINReduceAllMasked(short[] a, boolean[] mask) {
4226         short res = Short.MAX_VALUE;
4227         for (int i = 0; i < a.length; i += SPECIES.length()) {
4228             res = (short) VectorMath.minUnsigned(res, UMINReduceMasked(a, i, mask));
4229         }
4230 
4231         return res;
4232     }
4233 
4234     @Test(dataProvider = "shortUnaryOpMaskProvider")
4235     static void UMINReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
4236         short[] a = fa.apply(SPECIES.length());
4237         short[] r = fr.apply(SPECIES.length());
4238         boolean[] mask = fm.apply(SPECIES.length());
4239         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4240         short ra = Short.MAX_VALUE;
4241 
4242         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4243             for (int i = 0; i < a.length; i += SPECIES.length()) {
4244                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4245                 r[i] = av.reduceLanes(VectorOperators.UMIN, vmask);
4246             }
4247         }
4248 
4249         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4250             ra = Short.MAX_VALUE;
4251             for (int i = 0; i < a.length; i += SPECIES.length()) {
4252                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4253                 ra = (short) VectorMath.minUnsigned(ra, av.reduceLanes(VectorOperators.UMIN, vmask));
4254             }
4255         }
4256 
4257         assertReductionArraysEqualsMasked(r, ra, a, mask,
4258                 Short512VectorTests::UMINReduceMasked, Short512VectorTests::UMINReduceAllMasked);
4259     }
4260 
4261     static short UMAXReduce(short[] a, int idx) {
4262         short res = Short.MIN_VALUE;
4263         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4264             res = (short) VectorMath.maxUnsigned(res, a[i]);
4265         }
4266 
4267         return res;
4268     }
4269 
4270     static short UMAXReduceAll(short[] a) {
4271         short res = Short.MIN_VALUE;
4272         for (int i = 0; i < a.length; i += SPECIES.length()) {
4273             res = (short) VectorMath.maxUnsigned(res, UMAXReduce(a, i));
4274         }
4275 
4276         return res;
4277     }
4278 
4279     @Test(dataProvider = "shortUnaryOpProvider")
4280     static void UMAXReduceShort512VectorTests(IntFunction<short[]> fa) {
4281         short[] a = fa.apply(SPECIES.length());
4282         short[] r = fr.apply(SPECIES.length());
4283         short ra = Short.MIN_VALUE;
4284 
4285         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4286             for (int i = 0; i < a.length; i += SPECIES.length()) {
4287                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4288                 r[i] = av.reduceLanes(VectorOperators.UMAX);
4289             }
4290         }
4291 
4292         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4293             ra = Short.MIN_VALUE;
4294             for (int i = 0; i < a.length; i += SPECIES.length()) {
4295                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4296                 ra = (short) VectorMath.maxUnsigned(ra, av.reduceLanes(VectorOperators.UMAX));
4297             }
4298         }
4299 
4300         assertReductionArraysEquals(r, ra, a,
4301                 Short512VectorTests::UMAXReduce, Short512VectorTests::UMAXReduceAll);
4302     }
4303 
4304     static short UMAXReduceMasked(short[] a, int idx, boolean[] mask) {
4305         short res = Short.MIN_VALUE;
4306         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4307             if (mask[i % SPECIES.length()])
4308                 res = (short) VectorMath.maxUnsigned(res, a[i]);
4309         }
4310 
4311         return res;
4312     }
4313 
4314     static short UMAXReduceAllMasked(short[] a, boolean[] mask) {
4315         short res = Short.MIN_VALUE;
4316         for (int i = 0; i < a.length; i += SPECIES.length()) {
4317             res = (short) VectorMath.maxUnsigned(res, UMAXReduceMasked(a, i, mask));
4318         }
4319 
4320         return res;
4321     }
4322 
4323     @Test(dataProvider = "shortUnaryOpMaskProvider")
4324     static void UMAXReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
4325         short[] a = fa.apply(SPECIES.length());
4326         short[] r = fr.apply(SPECIES.length());
4327         boolean[] mask = fm.apply(SPECIES.length());
4328         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4329         short ra = Short.MIN_VALUE;
4330 
4331         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4332             for (int i = 0; i < a.length; i += SPECIES.length()) {
4333                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4334                 r[i] = av.reduceLanes(VectorOperators.UMAX, vmask);
4335             }
4336         }
4337 
4338         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4339             ra = Short.MIN_VALUE;
4340             for (int i = 0; i < a.length; i += SPECIES.length()) {
4341                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4342                 ra = (short) VectorMath.maxUnsigned(ra, av.reduceLanes(VectorOperators.UMAX, vmask));
4343             }
4344         }
4345 
4346         assertReductionArraysEqualsMasked(r, ra, a, mask,
4347                 Short512VectorTests::UMAXReduceMasked, Short512VectorTests::UMAXReduceAllMasked);
4348     }
4349 
4350     static short FIRST_NONZEROReduce(short[] a, int idx) {
4351         short res = (short) 0;
4352         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4353             res = firstNonZero(res, a[i]);
4354         }
4355 
4356         return res;
4357     }
4358 
4359     static short FIRST_NONZEROReduceAll(short[] a) {
4360         short res = (short) 0;
4361         for (int i = 0; i < a.length; i += SPECIES.length()) {
4362             res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
4363         }
4364 
4365         return res;
4366     }
4367 
4368     @Test(dataProvider = "shortUnaryOpProvider")
4369     static void FIRST_NONZEROReduceShort512VectorTests(IntFunction<short[]> fa) {
4370         short[] a = fa.apply(SPECIES.length());
4371         short[] r = fr.apply(SPECIES.length());
4372         short ra = (short) 0;
4373 
4374         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4375             for (int i = 0; i < a.length; i += SPECIES.length()) {
4376                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4377                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
4378             }
4379         }
4380 
4381         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4382             ra = (short) 0;
4383             for (int i = 0; i < a.length; i += SPECIES.length()) {
4384                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4385                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
4386             }
4387         }
4388 
4389         assertReductionArraysEquals(r, ra, a,
4390                 Short512VectorTests::FIRST_NONZEROReduce, Short512VectorTests::FIRST_NONZEROReduceAll);
4391     }
4392 
4393     static short FIRST_NONZEROReduceMasked(short[] a, int idx, boolean[] mask) {
4394         short res = (short) 0;
4395         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4396             if (mask[i % SPECIES.length()])
4397                 res = firstNonZero(res, a[i]);
4398         }
4399 
4400         return res;
4401     }
4402 
4403     static short FIRST_NONZEROReduceAllMasked(short[] a, boolean[] mask) {
4404         short res = (short) 0;
4405         for (int i = 0; i < a.length; i += SPECIES.length()) {
4406             res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
4407         }
4408 
4409         return res;
4410     }
4411 
4412     @Test(dataProvider = "shortUnaryOpMaskProvider")
4413     static void FIRST_NONZEROReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
4414         short[] a = fa.apply(SPECIES.length());
4415         short[] r = fr.apply(SPECIES.length());
4416         boolean[] mask = fm.apply(SPECIES.length());
4417         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4418         short ra = (short) 0;
4419 
4420         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4421             for (int i = 0; i < a.length; i += SPECIES.length()) {
4422                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4423                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
4424             }
4425         }
4426 
4427         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4428             ra = (short) 0;
4429             for (int i = 0; i < a.length; i += SPECIES.length()) {
4430                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4431                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
4432             }
4433         }
4434 
4435         assertReductionArraysEqualsMasked(r, ra, a, mask,
4436                 Short512VectorTests::FIRST_NONZEROReduceMasked, Short512VectorTests::FIRST_NONZEROReduceAllMasked);
4437     }
4438 
4439     static boolean anyTrue(boolean[] a, int idx) {
4440         boolean res = false;
4441         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4442             res |= a[i];
4443         }
4444 
4445         return res;
4446     }
4447 
4448     @Test(dataProvider = "boolUnaryOpProvider")
4449     static void anyTrueShort512VectorTests(IntFunction<boolean[]> fm) {
4450         boolean[] mask = fm.apply(SPECIES.length());
4451         boolean[] r = fmr.apply(SPECIES.length());
4452 
4453         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4454             for (int i = 0; i < mask.length; i += SPECIES.length()) {
4455                 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
4456                 r[i] = vmask.anyTrue();
4457             }
4458         }
4459 
4460         assertReductionBoolArraysEquals(r, mask, Short512VectorTests::anyTrue);
4461     }
4462 
4463     static boolean allTrue(boolean[] a, int idx) {
4464         boolean res = true;
4465         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4466             res &= a[i];
4467         }
4468 
4469         return res;
4470     }
4471 
4472     @Test(dataProvider = "boolUnaryOpProvider")
4473     static void allTrueShort512VectorTests(IntFunction<boolean[]> fm) {
4474         boolean[] mask = fm.apply(SPECIES.length());
4475         boolean[] r = fmr.apply(SPECIES.length());
4476 
4477         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4478             for (int i = 0; i < mask.length; i += SPECIES.length()) {
4479                 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
4480                 r[i] = vmask.allTrue();
4481             }
4482         }
4483 
4484         assertReductionBoolArraysEquals(r, mask, Short512VectorTests::allTrue);
4485     }
4486 
4487     static short SUADDReduce(short[] a, int idx) {
4488         short res = 0;
4489         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4490             res = (short) VectorMath.addSaturatingUnsigned(res, a[i]);
4491         }
4492 
4493         return res;
4494     }
4495 
4496     static short SUADDReduceAll(short[] a) {
4497         short res = 0;
4498         for (int i = 0; i < a.length; i += SPECIES.length()) {
4499             res = (short) VectorMath.addSaturatingUnsigned(res, SUADDReduce(a, i));
4500         }
4501 
4502         return res;
4503     }
4504 
4505     @Test(dataProvider = "shortSaturatingUnaryOpProvider")
4506     static void SUADDReduceShort512VectorTests(IntFunction<short[]> fa) {
4507         short[] a = fa.apply(SPECIES.length());
4508         short[] r = fr.apply(SPECIES.length());
4509         short ra = 0;
4510 
4511         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4512             for (int i = 0; i < a.length; i += SPECIES.length()) {
4513                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4514                 r[i] = av.reduceLanes(VectorOperators.SUADD);
4515             }
4516         }
4517 
4518         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4519             ra = 0;
4520             for (int i = 0; i < a.length; i += SPECIES.length()) {
4521                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4522                 ra = (short) VectorMath.addSaturatingUnsigned(ra, av.reduceLanes(VectorOperators.SUADD));
4523             }
4524         }
4525 
4526         assertReductionArraysEquals(r, ra, a,
4527                 Short512VectorTests::SUADDReduce, Short512VectorTests::SUADDReduceAll);
4528     }
4529 
4530     static short SUADDReduceMasked(short[] a, int idx, boolean[] mask) {
4531         short res = 0;
4532         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4533             if (mask[i % SPECIES.length()])
4534                 res = (short) VectorMath.addSaturatingUnsigned(res, a[i]);
4535         }
4536 
4537         return res;
4538     }
4539 
4540     static short SUADDReduceAllMasked(short[] a, boolean[] mask) {
4541         short res = 0;
4542         for (int i = 0; i < a.length; i += SPECIES.length()) {
4543             res = (short) VectorMath.addSaturatingUnsigned(res, SUADDReduceMasked(a, i, mask));
4544         }
4545 
4546         return res;
4547     }
4548     @Test(dataProvider = "shortSaturatingUnaryOpMaskProvider")
4549     static void SUADDReduceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
4550         short[] a = fa.apply(SPECIES.length());
4551         short[] r = fr.apply(SPECIES.length());
4552         boolean[] mask = fm.apply(SPECIES.length());
4553         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4554         short ra = 0;
4555 
4556         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4557             for (int i = 0; i < a.length; i += SPECIES.length()) {
4558                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4559                 r[i] = av.reduceLanes(VectorOperators.SUADD, vmask);
4560             }
4561         }
4562 
4563         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4564             ra = 0;
4565             for (int i = 0; i < a.length; i += SPECIES.length()) {
4566                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4567                 ra = (short) VectorMath.addSaturatingUnsigned(ra, av.reduceLanes(VectorOperators.SUADD, vmask));
4568             }
4569         }
4570 
4571         assertReductionArraysEqualsMasked(r, ra, a, mask,
4572                 Short512VectorTests::SUADDReduceMasked, Short512VectorTests::SUADDReduceAllMasked);
4573     }
4574 
4575     @Test(dataProvider = "shortBinaryOpProvider")
4576     static void withShort512VectorTests(IntFunction<short []> fa, IntFunction<short []> fb) {
4577         short[] a = fa.apply(SPECIES.length());
4578         short[] b = fb.apply(SPECIES.length());
4579         short[] r = fr.apply(SPECIES.length());
4580 
4581         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4582             for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
4583                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4584                 av.withLane(j, b[i + j]).intoArray(r, i);
4585                 a[i + j] = b[i + j];
4586                 j = (j + 1) & (SPECIES.length() - 1);
4587             }
4588         }
4589 
4590 
4591         assertArraysStrictlyEquals(r, a);
4592     }
4593 
4594     static boolean testIS_DEFAULT(short a) {
4595         return bits(a)==0;
4596     }
4597 
4598     @Test(dataProvider = "shortTestOpProvider")
4599     static void IS_DEFAULTShort512VectorTests(IntFunction<short[]> fa) {
4600         short[] a = fa.apply(SPECIES.length());
4601 
4602         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4603             for (int i = 0; i < a.length; i += SPECIES.length()) {
4604                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4605                 VectorMask<Short> mv = av.test(VectorOperators.IS_DEFAULT);
4606 
4607                 // Check results as part of computation.
4608                 for (int j = 0; j < SPECIES.length(); j++) {
4609                     Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
4610                 }
4611             }
4612         }
4613     }
4614 
4615     @Test(dataProvider = "shortTestOpMaskProvider")
4616     static void IS_DEFAULTMaskedShort512VectorTests(IntFunction<short[]> fa,
4617                                           IntFunction<boolean[]> fm) {
4618         short[] a = fa.apply(SPECIES.length());
4619         boolean[] mask = fm.apply(SPECIES.length());
4620         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4621 
4622         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4623             for (int i = 0; i < a.length; i += SPECIES.length()) {
4624                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4625                 VectorMask<Short> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
4626 
4627                 // Check results as part of computation.
4628                 for (int j = 0; j < SPECIES.length(); j++) {
4629                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
4630                 }
4631             }
4632         }
4633     }
4634 
4635     static boolean testIS_NEGATIVE(short a) {
4636         return bits(a)<0;
4637     }
4638 
4639     @Test(dataProvider = "shortTestOpProvider")
4640     static void IS_NEGATIVEShort512VectorTests(IntFunction<short[]> fa) {
4641         short[] a = fa.apply(SPECIES.length());
4642 
4643         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4644             for (int i = 0; i < a.length; i += SPECIES.length()) {
4645                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4646                 VectorMask<Short> mv = av.test(VectorOperators.IS_NEGATIVE);
4647 
4648                 // Check results as part of computation.
4649                 for (int j = 0; j < SPECIES.length(); j++) {
4650                     Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
4651                 }
4652             }
4653         }
4654     }
4655 
4656     @Test(dataProvider = "shortTestOpMaskProvider")
4657     static void IS_NEGATIVEMaskedShort512VectorTests(IntFunction<short[]> fa,
4658                                           IntFunction<boolean[]> fm) {
4659         short[] a = fa.apply(SPECIES.length());
4660         boolean[] mask = fm.apply(SPECIES.length());
4661         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4662 
4663         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4664             for (int i = 0; i < a.length; i += SPECIES.length()) {
4665                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4666                 VectorMask<Short> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
4667 
4668                 // Check results as part of computation.
4669                 for (int j = 0; j < SPECIES.length(); j++) {
4670                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
4671                 }
4672             }
4673         }
4674     }
4675 
4676     @Test(dataProvider = "shortCompareOpProvider")
4677     static void LTShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4678         short[] a = fa.apply(SPECIES.length());
4679         short[] b = fb.apply(SPECIES.length());
4680 
4681         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4682             for (int i = 0; i < a.length; i += SPECIES.length()) {
4683                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4684                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4685                 VectorMask<Short> mv = av.compare(VectorOperators.LT, bv);
4686 
4687                 // Check results as part of computation.
4688                 for (int j = 0; j < SPECIES.length(); j++) {
4689                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
4690                 }
4691             }
4692         }
4693     }
4694 
4695     @Test(dataProvider = "shortCompareOpProvider")
4696     static void ltShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4697         short[] a = fa.apply(SPECIES.length());
4698         short[] b = fb.apply(SPECIES.length());
4699 
4700         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4701             for (int i = 0; i < a.length; i += SPECIES.length()) {
4702                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4703                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4704                 VectorMask<Short> mv = av.lt(bv);
4705 
4706                 // Check results as part of computation.
4707                 for (int j = 0; j < SPECIES.length(); j++) {
4708                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
4709                 }
4710             }
4711         }
4712     }
4713 
4714     @Test(dataProvider = "shortCompareOpMaskProvider")
4715     static void LTShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4716                                                 IntFunction<boolean[]> fm) {
4717         short[] a = fa.apply(SPECIES.length());
4718         short[] b = fb.apply(SPECIES.length());
4719         boolean[] mask = fm.apply(SPECIES.length());
4720 
4721         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4722 
4723         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4724             for (int i = 0; i < a.length; i += SPECIES.length()) {
4725                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4726                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4727                 VectorMask<Short> mv = av.compare(VectorOperators.LT, bv, vmask);
4728 
4729                 // Check results as part of computation.
4730                 for (int j = 0; j < SPECIES.length(); j++) {
4731                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
4732                 }
4733             }
4734         }
4735     }
4736 
4737     @Test(dataProvider = "shortCompareOpProvider")
4738     static void GTShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4739         short[] a = fa.apply(SPECIES.length());
4740         short[] b = fb.apply(SPECIES.length());
4741 
4742         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4743             for (int i = 0; i < a.length; i += SPECIES.length()) {
4744                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4745                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4746                 VectorMask<Short> mv = av.compare(VectorOperators.GT, bv);
4747 
4748                 // Check results as part of computation.
4749                 for (int j = 0; j < SPECIES.length(); j++) {
4750                     Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
4751                 }
4752             }
4753         }
4754     }
4755 
4756     @Test(dataProvider = "shortCompareOpMaskProvider")
4757     static void GTShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4758                                                 IntFunction<boolean[]> fm) {
4759         short[] a = fa.apply(SPECIES.length());
4760         short[] b = fb.apply(SPECIES.length());
4761         boolean[] mask = fm.apply(SPECIES.length());
4762 
4763         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4764 
4765         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4766             for (int i = 0; i < a.length; i += SPECIES.length()) {
4767                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4768                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4769                 VectorMask<Short> mv = av.compare(VectorOperators.GT, bv, vmask);
4770 
4771                 // Check results as part of computation.
4772                 for (int j = 0; j < SPECIES.length(); j++) {
4773                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
4774                 }
4775             }
4776         }
4777     }
4778 
4779     @Test(dataProvider = "shortCompareOpProvider")
4780     static void EQShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4781         short[] a = fa.apply(SPECIES.length());
4782         short[] b = fb.apply(SPECIES.length());
4783 
4784         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4785             for (int i = 0; i < a.length; i += SPECIES.length()) {
4786                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4787                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4788                 VectorMask<Short> mv = av.compare(VectorOperators.EQ, bv);
4789 
4790                 // Check results as part of computation.
4791                 for (int j = 0; j < SPECIES.length(); j++) {
4792                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4793                 }
4794             }
4795         }
4796     }
4797 
4798     @Test(dataProvider = "shortCompareOpProvider")
4799     static void eqShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4800         short[] a = fa.apply(SPECIES.length());
4801         short[] b = fb.apply(SPECIES.length());
4802 
4803         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4804             for (int i = 0; i < a.length; i += SPECIES.length()) {
4805                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4806                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4807                 VectorMask<Short> mv = av.eq(bv);
4808 
4809                 // Check results as part of computation.
4810                 for (int j = 0; j < SPECIES.length(); j++) {
4811                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4812                 }
4813             }
4814         }
4815     }
4816 
4817     @Test(dataProvider = "shortCompareOpMaskProvider")
4818     static void EQShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4819                                                 IntFunction<boolean[]> fm) {
4820         short[] a = fa.apply(SPECIES.length());
4821         short[] b = fb.apply(SPECIES.length());
4822         boolean[] mask = fm.apply(SPECIES.length());
4823 
4824         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4825 
4826         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4827             for (int i = 0; i < a.length; i += SPECIES.length()) {
4828                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4829                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4830                 VectorMask<Short> mv = av.compare(VectorOperators.EQ, bv, vmask);
4831 
4832                 // Check results as part of computation.
4833                 for (int j = 0; j < SPECIES.length(); j++) {
4834                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
4835                 }
4836             }
4837         }
4838     }
4839 
4840     @Test(dataProvider = "shortCompareOpProvider")
4841     static void NEShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4842         short[] a = fa.apply(SPECIES.length());
4843         short[] b = fb.apply(SPECIES.length());
4844 
4845         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4846             for (int i = 0; i < a.length; i += SPECIES.length()) {
4847                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4848                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4849                 VectorMask<Short> mv = av.compare(VectorOperators.NE, bv);
4850 
4851                 // Check results as part of computation.
4852                 for (int j = 0; j < SPECIES.length(); j++) {
4853                     Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
4854                 }
4855             }
4856         }
4857     }
4858 
4859     @Test(dataProvider = "shortCompareOpMaskProvider")
4860     static void NEShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4861                                                 IntFunction<boolean[]> fm) {
4862         short[] a = fa.apply(SPECIES.length());
4863         short[] b = fb.apply(SPECIES.length());
4864         boolean[] mask = fm.apply(SPECIES.length());
4865 
4866         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4867 
4868         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4869             for (int i = 0; i < a.length; i += SPECIES.length()) {
4870                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4871                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4872                 VectorMask<Short> mv = av.compare(VectorOperators.NE, bv, vmask);
4873 
4874                 // Check results as part of computation.
4875                 for (int j = 0; j < SPECIES.length(); j++) {
4876                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
4877                 }
4878             }
4879         }
4880     }
4881 
4882     @Test(dataProvider = "shortCompareOpProvider")
4883     static void LEShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4884         short[] a = fa.apply(SPECIES.length());
4885         short[] b = fb.apply(SPECIES.length());
4886 
4887         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4888             for (int i = 0; i < a.length; i += SPECIES.length()) {
4889                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4890                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4891                 VectorMask<Short> mv = av.compare(VectorOperators.LE, bv);
4892 
4893                 // Check results as part of computation.
4894                 for (int j = 0; j < SPECIES.length(); j++) {
4895                     Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
4896                 }
4897             }
4898         }
4899     }
4900 
4901     @Test(dataProvider = "shortCompareOpMaskProvider")
4902     static void LEShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4903                                                 IntFunction<boolean[]> fm) {
4904         short[] a = fa.apply(SPECIES.length());
4905         short[] b = fb.apply(SPECIES.length());
4906         boolean[] mask = fm.apply(SPECIES.length());
4907 
4908         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4909 
4910         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4911             for (int i = 0; i < a.length; i += SPECIES.length()) {
4912                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4913                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4914                 VectorMask<Short> mv = av.compare(VectorOperators.LE, bv, vmask);
4915 
4916                 // Check results as part of computation.
4917                 for (int j = 0; j < SPECIES.length(); j++) {
4918                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
4919                 }
4920             }
4921         }
4922     }
4923 
4924     @Test(dataProvider = "shortCompareOpProvider")
4925     static void GEShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4926         short[] a = fa.apply(SPECIES.length());
4927         short[] b = fb.apply(SPECIES.length());
4928 
4929         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4930             for (int i = 0; i < a.length; i += SPECIES.length()) {
4931                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4932                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4933                 VectorMask<Short> mv = av.compare(VectorOperators.GE, bv);
4934 
4935                 // Check results as part of computation.
4936                 for (int j = 0; j < SPECIES.length(); j++) {
4937                     Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
4938                 }
4939             }
4940         }
4941     }
4942 
4943     @Test(dataProvider = "shortCompareOpMaskProvider")
4944     static void GEShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4945                                                 IntFunction<boolean[]> fm) {
4946         short[] a = fa.apply(SPECIES.length());
4947         short[] b = fb.apply(SPECIES.length());
4948         boolean[] mask = fm.apply(SPECIES.length());
4949 
4950         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4951 
4952         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4953             for (int i = 0; i < a.length; i += SPECIES.length()) {
4954                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4955                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4956                 VectorMask<Short> mv = av.compare(VectorOperators.GE, bv, vmask);
4957 
4958                 // Check results as part of computation.
4959                 for (int j = 0; j < SPECIES.length(); j++) {
4960                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
4961                 }
4962             }
4963         }
4964     }
4965 
4966     @Test(dataProvider = "shortCompareOpProvider")
4967     static void ULTShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4968         short[] a = fa.apply(SPECIES.length());
4969         short[] b = fb.apply(SPECIES.length());
4970 
4971         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4972             for (int i = 0; i < a.length; i += SPECIES.length()) {
4973                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4974                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4975                 VectorMask<Short> mv = av.compare(VectorOperators.ULT, bv);
4976 
4977                 // Check results as part of computation.
4978                 for (int j = 0; j < SPECIES.length(); j++) {
4979                     Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
4980                 }
4981             }
4982         }
4983     }
4984 
4985     @Test(dataProvider = "shortCompareOpMaskProvider")
4986     static void ULTShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4987                                                 IntFunction<boolean[]> fm) {
4988         short[] a = fa.apply(SPECIES.length());
4989         short[] b = fb.apply(SPECIES.length());
4990         boolean[] mask = fm.apply(SPECIES.length());
4991 
4992         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4993 
4994         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4995             for (int i = 0; i < a.length; i += SPECIES.length()) {
4996                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4997                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4998                 VectorMask<Short> mv = av.compare(VectorOperators.ULT, bv, vmask);
4999 
5000                 // Check results as part of computation.
5001                 for (int j = 0; j < SPECIES.length(); j++) {
5002                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
5003                 }
5004             }
5005         }
5006     }
5007 
5008     @Test(dataProvider = "shortCompareOpProvider")
5009     static void UGTShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5010         short[] a = fa.apply(SPECIES.length());
5011         short[] b = fb.apply(SPECIES.length());
5012 
5013         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5014             for (int i = 0; i < a.length; i += SPECIES.length()) {
5015                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5016                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5017                 VectorMask<Short> mv = av.compare(VectorOperators.UGT, bv);
5018 
5019                 // Check results as part of computation.
5020                 for (int j = 0; j < SPECIES.length(); j++) {
5021                     Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
5022                 }
5023             }
5024         }
5025     }
5026 
5027     @Test(dataProvider = "shortCompareOpMaskProvider")
5028     static void UGTShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
5029                                                 IntFunction<boolean[]> fm) {
5030         short[] a = fa.apply(SPECIES.length());
5031         short[] b = fb.apply(SPECIES.length());
5032         boolean[] mask = fm.apply(SPECIES.length());
5033 
5034         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5035 
5036         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5037             for (int i = 0; i < a.length; i += SPECIES.length()) {
5038                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5039                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5040                 VectorMask<Short> mv = av.compare(VectorOperators.UGT, bv, vmask);
5041 
5042                 // Check results as part of computation.
5043                 for (int j = 0; j < SPECIES.length(); j++) {
5044                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
5045                 }
5046             }
5047         }
5048     }
5049 
5050     @Test(dataProvider = "shortCompareOpProvider")
5051     static void ULEShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5052         short[] a = fa.apply(SPECIES.length());
5053         short[] b = fb.apply(SPECIES.length());
5054 
5055         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5056             for (int i = 0; i < a.length; i += SPECIES.length()) {
5057                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5058                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5059                 VectorMask<Short> mv = av.compare(VectorOperators.ULE, bv);
5060 
5061                 // Check results as part of computation.
5062                 for (int j = 0; j < SPECIES.length(); j++) {
5063                     Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
5064                 }
5065             }
5066         }
5067     }
5068 
5069     @Test(dataProvider = "shortCompareOpMaskProvider")
5070     static void ULEShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
5071                                                 IntFunction<boolean[]> fm) {
5072         short[] a = fa.apply(SPECIES.length());
5073         short[] b = fb.apply(SPECIES.length());
5074         boolean[] mask = fm.apply(SPECIES.length());
5075 
5076         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5077 
5078         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5079             for (int i = 0; i < a.length; i += SPECIES.length()) {
5080                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5081                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5082                 VectorMask<Short> mv = av.compare(VectorOperators.ULE, bv, vmask);
5083 
5084                 // Check results as part of computation.
5085                 for (int j = 0; j < SPECIES.length(); j++) {
5086                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j]));
5087                 }
5088             }
5089         }
5090     }
5091 
5092     @Test(dataProvider = "shortCompareOpProvider")
5093     static void UGEShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5094         short[] a = fa.apply(SPECIES.length());
5095         short[] b = fb.apply(SPECIES.length());
5096 
5097         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5098             for (int i = 0; i < a.length; i += SPECIES.length()) {
5099                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5100                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5101                 VectorMask<Short> mv = av.compare(VectorOperators.UGE, bv);
5102 
5103                 // Check results as part of computation.
5104                 for (int j = 0; j < SPECIES.length(); j++) {
5105                     Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
5106                 }
5107             }
5108         }
5109     }
5110 
5111     @Test(dataProvider = "shortCompareOpMaskProvider")
5112     static void UGEShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
5113                                                 IntFunction<boolean[]> fm) {
5114         short[] a = fa.apply(SPECIES.length());
5115         short[] b = fb.apply(SPECIES.length());
5116         boolean[] mask = fm.apply(SPECIES.length());
5117 
5118         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5119 
5120         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5121             for (int i = 0; i < a.length; i += SPECIES.length()) {
5122                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5123                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5124                 VectorMask<Short> mv = av.compare(VectorOperators.UGE, bv, vmask);
5125 
5126                 // Check results as part of computation.
5127                 for (int j = 0; j < SPECIES.length(); j++) {
5128                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
5129                 }
5130             }
5131         }
5132     }
5133 
5134     @Test(dataProvider = "shortCompareOpProvider")
5135     static void LTShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5136         short[] a = fa.apply(SPECIES.length());
5137         short[] b = fb.apply(SPECIES.length());
5138 
5139         for (int i = 0; i < a.length; i += SPECIES.length()) {
5140             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5141             VectorMask<Short> mv = av.compare(VectorOperators.LT, b[i]);
5142 
5143             // Check results as part of computation.
5144             for (int j = 0; j < SPECIES.length(); j++) {
5145                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
5146             }
5147         }
5148     }
5149 
5150     @Test(dataProvider = "shortCompareOpMaskProvider")
5151     static void LTShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa,
5152                                 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
5153         short[] a = fa.apply(SPECIES.length());
5154         short[] b = fb.apply(SPECIES.length());
5155         boolean[] mask = fm.apply(SPECIES.length());
5156 
5157         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5158 
5159         for (int i = 0; i < a.length; i += SPECIES.length()) {
5160             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5161             VectorMask<Short> mv = av.compare(VectorOperators.LT, b[i], vmask);
5162 
5163             // Check results as part of computation.
5164             for (int j = 0; j < SPECIES.length(); j++) {
5165                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
5166             }
5167         }
5168     }
5169 
5170     @Test(dataProvider = "shortCompareOpProvider")
5171     static void LTShort512VectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5172         short[] a = fa.apply(SPECIES.length());
5173         short[] b = fb.apply(SPECIES.length());
5174 
5175         for (int i = 0; i < a.length; i += SPECIES.length()) {
5176             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5177             VectorMask<Short> mv = av.compare(VectorOperators.LT, (long)b[i]);
5178 
5179             // Check results as part of computation.
5180             for (int j = 0; j < SPECIES.length(); j++) {
5181                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (short)((long)b[i]));
5182             }
5183         }
5184     }
5185 
5186     @Test(dataProvider = "shortCompareOpMaskProvider")
5187     static void LTShort512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<short[]> fa,
5188                                 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
5189         short[] a = fa.apply(SPECIES.length());
5190         short[] b = fb.apply(SPECIES.length());
5191         boolean[] mask = fm.apply(SPECIES.length());
5192 
5193         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5194 
5195         for (int i = 0; i < a.length; i += SPECIES.length()) {
5196             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5197             VectorMask<Short> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
5198 
5199             // Check results as part of computation.
5200             for (int j = 0; j < SPECIES.length(); j++) {
5201                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (short)((long)b[i])));
5202             }
5203         }
5204     }
5205 
5206     @Test(dataProvider = "shortCompareOpProvider")
5207     static void EQShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5208         short[] a = fa.apply(SPECIES.length());
5209         short[] b = fb.apply(SPECIES.length());
5210 
5211         for (int i = 0; i < a.length; i += SPECIES.length()) {
5212             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5213             VectorMask<Short> mv = av.compare(VectorOperators.EQ, b[i]);
5214 
5215             // Check results as part of computation.
5216             for (int j = 0; j < SPECIES.length(); j++) {
5217                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
5218             }
5219         }
5220     }
5221 
5222     @Test(dataProvider = "shortCompareOpMaskProvider")
5223     static void EQShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa,
5224                                 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
5225         short[] a = fa.apply(SPECIES.length());
5226         short[] b = fb.apply(SPECIES.length());
5227         boolean[] mask = fm.apply(SPECIES.length());
5228 
5229         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5230 
5231         for (int i = 0; i < a.length; i += SPECIES.length()) {
5232             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5233             VectorMask<Short> mv = av.compare(VectorOperators.EQ, b[i], vmask);
5234 
5235             // Check results as part of computation.
5236             for (int j = 0; j < SPECIES.length(); j++) {
5237                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
5238             }
5239         }
5240     }
5241 
5242     @Test(dataProvider = "shortCompareOpProvider")
5243     static void EQShort512VectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5244         short[] a = fa.apply(SPECIES.length());
5245         short[] b = fb.apply(SPECIES.length());
5246 
5247         for (int i = 0; i < a.length; i += SPECIES.length()) {
5248             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5249             VectorMask<Short> mv = av.compare(VectorOperators.EQ, (long)b[i]);
5250 
5251             // Check results as part of computation.
5252             for (int j = 0; j < SPECIES.length(); j++) {
5253                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (short)((long)b[i]));
5254             }
5255         }
5256     }
5257 
5258     @Test(dataProvider = "shortCompareOpMaskProvider")
5259     static void EQShort512VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<short[]> fa,
5260                                 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
5261         short[] a = fa.apply(SPECIES.length());
5262         short[] b = fb.apply(SPECIES.length());
5263         boolean[] mask = fm.apply(SPECIES.length());
5264 
5265         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5266 
5267         for (int i = 0; i < a.length; i += SPECIES.length()) {
5268             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5269             VectorMask<Short> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
5270 
5271             // Check results as part of computation.
5272             for (int j = 0; j < SPECIES.length(); j++) {
5273                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (short)((long)b[i])));
5274             }
5275         }
5276     }
5277 
5278     static short blend(short a, short b, boolean mask) {
5279         return mask ? b : a;
5280     }
5281 
5282     @Test(dataProvider = "shortBinaryOpMaskProvider")
5283     static void blendShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb,
5284                                           IntFunction<boolean[]> fm) {
5285         short[] a = fa.apply(SPECIES.length());
5286         short[] b = fb.apply(SPECIES.length());
5287         short[] r = fr.apply(SPECIES.length());
5288         boolean[] mask = fm.apply(SPECIES.length());
5289         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5290 
5291         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5292             for (int i = 0; i < a.length; i += SPECIES.length()) {
5293                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5294                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5295                 av.blend(bv, vmask).intoArray(r, i);
5296             }
5297         }
5298 
5299         assertArraysEquals(r, a, b, mask, Short512VectorTests::blend);
5300     }
5301 
5302     @Test(dataProvider = "shortUnaryOpShuffleProvider")
5303     static void RearrangeShort512VectorTests(IntFunction<short[]> fa,
5304                                            BiFunction<Integer,Integer,int[]> fs) {
5305         short[] a = fa.apply(SPECIES.length());
5306         int[] order = fs.apply(a.length, SPECIES.length());
5307         short[] r = fr.apply(SPECIES.length());
5308 
5309         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5310             for (int i = 0; i < a.length; i += SPECIES.length()) {
5311                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5312                 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
5313             }
5314         }
5315 
5316         assertRearrangeArraysEquals(r, a, order, SPECIES.length());
5317     }
5318 
5319     @Test(dataProvider = "shortUnaryOpShuffleMaskProvider")
5320     static void RearrangeShort512VectorTestsMaskedSmokeTest(IntFunction<short[]> fa,
5321                                                           BiFunction<Integer,Integer,int[]> fs,
5322                                                           IntFunction<boolean[]> fm) {
5323         short[] a = fa.apply(SPECIES.length());
5324         int[] order = fs.apply(a.length, SPECIES.length());
5325         short[] r = fr.apply(SPECIES.length());
5326         boolean[] mask = fm.apply(SPECIES.length());
5327         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5328 
5329         for (int i = 0; i < a.length; i += SPECIES.length()) {
5330             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5331             av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
5332         }
5333 
5334         assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
5335     }
5336 
5337     @Test(dataProvider = "shortUnaryOpMaskProvider")
5338     static void compressShort512VectorTests(IntFunction<short[]> fa,
5339                                                 IntFunction<boolean[]> fm) {
5340         short[] a = fa.apply(SPECIES.length());
5341         short[] r = fr.apply(SPECIES.length());
5342         boolean[] mask = fm.apply(SPECIES.length());
5343         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5344 
5345         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5346             for (int i = 0; i < a.length; i += SPECIES.length()) {
5347                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5348                 av.compress(vmask).intoArray(r, i);
5349             }
5350         }
5351 
5352         assertcompressArraysEquals(r, a, mask, SPECIES.length());
5353     }
5354 
5355     @Test(dataProvider = "shortUnaryOpMaskProvider")
5356     static void expandShort512VectorTests(IntFunction<short[]> fa,
5357                                                 IntFunction<boolean[]> fm) {
5358         short[] a = fa.apply(SPECIES.length());
5359         short[] r = fr.apply(SPECIES.length());
5360         boolean[] mask = fm.apply(SPECIES.length());
5361         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5362 
5363         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5364             for (int i = 0; i < a.length; i += SPECIES.length()) {
5365                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5366                 av.expand(vmask).intoArray(r, i);
5367             }
5368         }
5369 
5370         assertexpandArraysEquals(r, a, mask, SPECIES.length());
5371     }
5372 
5373     @Test(dataProvider = "shortUnaryOpProvider")
5374     static void getShort512VectorTests(IntFunction<short[]> fa) {
5375         short[] a = fa.apply(SPECIES.length());
5376         short[] r = fr.apply(SPECIES.length());
5377 
5378         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5379             for (int i = 0; i < a.length; i += SPECIES.length()) {
5380                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5381                 int num_lanes = SPECIES.length();
5382                 // Manually unroll because full unroll happens after intrinsification.
5383                 // Unroll is needed because get intrinsic requires for index to be a known constant.
5384                 if (num_lanes == 1) {
5385                     r[i]=av.lane(0);
5386                 } else if (num_lanes == 2) {
5387                     r[i]=av.lane(0);
5388                     r[i+1]=av.lane(1);
5389                 } else if (num_lanes == 4) {
5390                     r[i]=av.lane(0);
5391                     r[i+1]=av.lane(1);
5392                     r[i+2]=av.lane(2);
5393                     r[i+3]=av.lane(3);
5394                 } else if (num_lanes == 8) {
5395                     r[i]=av.lane(0);
5396                     r[i+1]=av.lane(1);
5397                     r[i+2]=av.lane(2);
5398                     r[i+3]=av.lane(3);
5399                     r[i+4]=av.lane(4);
5400                     r[i+5]=av.lane(5);
5401                     r[i+6]=av.lane(6);
5402                     r[i+7]=av.lane(7);
5403                 } else if (num_lanes == 16) {
5404                     r[i]=av.lane(0);
5405                     r[i+1]=av.lane(1);
5406                     r[i+2]=av.lane(2);
5407                     r[i+3]=av.lane(3);
5408                     r[i+4]=av.lane(4);
5409                     r[i+5]=av.lane(5);
5410                     r[i+6]=av.lane(6);
5411                     r[i+7]=av.lane(7);
5412                     r[i+8]=av.lane(8);
5413                     r[i+9]=av.lane(9);
5414                     r[i+10]=av.lane(10);
5415                     r[i+11]=av.lane(11);
5416                     r[i+12]=av.lane(12);
5417                     r[i+13]=av.lane(13);
5418                     r[i+14]=av.lane(14);
5419                     r[i+15]=av.lane(15);
5420                 } else if (num_lanes == 32) {
5421                     r[i]=av.lane(0);
5422                     r[i+1]=av.lane(1);
5423                     r[i+2]=av.lane(2);
5424                     r[i+3]=av.lane(3);
5425                     r[i+4]=av.lane(4);
5426                     r[i+5]=av.lane(5);
5427                     r[i+6]=av.lane(6);
5428                     r[i+7]=av.lane(7);
5429                     r[i+8]=av.lane(8);
5430                     r[i+9]=av.lane(9);
5431                     r[i+10]=av.lane(10);
5432                     r[i+11]=av.lane(11);
5433                     r[i+12]=av.lane(12);
5434                     r[i+13]=av.lane(13);
5435                     r[i+14]=av.lane(14);
5436                     r[i+15]=av.lane(15);
5437                     r[i+16]=av.lane(16);
5438                     r[i+17]=av.lane(17);
5439                     r[i+18]=av.lane(18);
5440                     r[i+19]=av.lane(19);
5441                     r[i+20]=av.lane(20);
5442                     r[i+21]=av.lane(21);
5443                     r[i+22]=av.lane(22);
5444                     r[i+23]=av.lane(23);
5445                     r[i+24]=av.lane(24);
5446                     r[i+25]=av.lane(25);
5447                     r[i+26]=av.lane(26);
5448                     r[i+27]=av.lane(27);
5449                     r[i+28]=av.lane(28);
5450                     r[i+29]=av.lane(29);
5451                     r[i+30]=av.lane(30);
5452                     r[i+31]=av.lane(31);
5453                 } else if (num_lanes == 64) {
5454                     r[i]=av.lane(0);
5455                     r[i+1]=av.lane(1);
5456                     r[i+2]=av.lane(2);
5457                     r[i+3]=av.lane(3);
5458                     r[i+4]=av.lane(4);
5459                     r[i+5]=av.lane(5);
5460                     r[i+6]=av.lane(6);
5461                     r[i+7]=av.lane(7);
5462                     r[i+8]=av.lane(8);
5463                     r[i+9]=av.lane(9);
5464                     r[i+10]=av.lane(10);
5465                     r[i+11]=av.lane(11);
5466                     r[i+12]=av.lane(12);
5467                     r[i+13]=av.lane(13);
5468                     r[i+14]=av.lane(14);
5469                     r[i+15]=av.lane(15);
5470                     r[i+16]=av.lane(16);
5471                     r[i+17]=av.lane(17);
5472                     r[i+18]=av.lane(18);
5473                     r[i+19]=av.lane(19);
5474                     r[i+20]=av.lane(20);
5475                     r[i+21]=av.lane(21);
5476                     r[i+22]=av.lane(22);
5477                     r[i+23]=av.lane(23);
5478                     r[i+24]=av.lane(24);
5479                     r[i+25]=av.lane(25);
5480                     r[i+26]=av.lane(26);
5481                     r[i+27]=av.lane(27);
5482                     r[i+28]=av.lane(28);
5483                     r[i+29]=av.lane(29);
5484                     r[i+30]=av.lane(30);
5485                     r[i+31]=av.lane(31);
5486                     r[i+32]=av.lane(32);
5487                     r[i+33]=av.lane(33);
5488                     r[i+34]=av.lane(34);
5489                     r[i+35]=av.lane(35);
5490                     r[i+36]=av.lane(36);
5491                     r[i+37]=av.lane(37);
5492                     r[i+38]=av.lane(38);
5493                     r[i+39]=av.lane(39);
5494                     r[i+40]=av.lane(40);
5495                     r[i+41]=av.lane(41);
5496                     r[i+42]=av.lane(42);
5497                     r[i+43]=av.lane(43);
5498                     r[i+44]=av.lane(44);
5499                     r[i+45]=av.lane(45);
5500                     r[i+46]=av.lane(46);
5501                     r[i+47]=av.lane(47);
5502                     r[i+48]=av.lane(48);
5503                     r[i+49]=av.lane(49);
5504                     r[i+50]=av.lane(50);
5505                     r[i+51]=av.lane(51);
5506                     r[i+52]=av.lane(52);
5507                     r[i+53]=av.lane(53);
5508                     r[i+54]=av.lane(54);
5509                     r[i+55]=av.lane(55);
5510                     r[i+56]=av.lane(56);
5511                     r[i+57]=av.lane(57);
5512                     r[i+58]=av.lane(58);
5513                     r[i+59]=av.lane(59);
5514                     r[i+60]=av.lane(60);
5515                     r[i+61]=av.lane(61);
5516                     r[i+62]=av.lane(62);
5517                     r[i+63]=av.lane(63);
5518                 } else {
5519                     for (int j = 0; j < SPECIES.length(); j++) {
5520                         r[i+j]=av.lane(j);
5521                     }
5522                 }
5523             }
5524         }
5525 
5526         assertArraysStrictlyEquals(r, a);
5527     }
5528 
5529     @Test(dataProvider = "shortUnaryOpProvider")
5530     static void BroadcastShort512VectorTests(IntFunction<short[]> fa) {
5531         short[] a = fa.apply(SPECIES.length());
5532         short[] r = new short[a.length];
5533 
5534         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5535             for (int i = 0; i < a.length; i += SPECIES.length()) {
5536                 ShortVector.broadcast(SPECIES, a[i]).intoArray(r, i);
5537             }
5538         }
5539 
5540         assertBroadcastArraysEquals(r, a);
5541     }
5542 
5543     @Test(dataProvider = "shortUnaryOpProvider")
5544     static void ZeroShort512VectorTests(IntFunction<short[]> fa) {
5545         short[] a = fa.apply(SPECIES.length());
5546         short[] r = new short[a.length];
5547 
5548         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5549             for (int i = 0; i < a.length; i += SPECIES.length()) {
5550                 ShortVector.zero(SPECIES).intoArray(a, i);
5551             }
5552         }
5553 
5554         Assert.assertEquals(a, r);
5555     }
5556 
5557     static short[] sliceUnary(short[] a, int origin, int idx) {
5558         short[] res = new short[SPECIES.length()];
5559         for (int i = 0; i < SPECIES.length(); i++){
5560             if(i+origin < SPECIES.length())
5561                 res[i] = a[idx+i+origin];
5562             else
5563                 res[i] = (short)0;
5564         }
5565         return res;
5566     }
5567 
5568     @Test(dataProvider = "shortUnaryOpProvider")
5569     static void sliceUnaryShort512VectorTests(IntFunction<short[]> fa) {
5570         short[] a = fa.apply(SPECIES.length());
5571         short[] r = new short[a.length];
5572         int origin = RAND.nextInt(SPECIES.length());
5573         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5574             for (int i = 0; i < a.length; i += SPECIES.length()) {
5575                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5576                 av.slice(origin).intoArray(r, i);
5577             }
5578         }
5579 
5580         assertArraysEquals(r, a, origin, Short512VectorTests::sliceUnary);
5581     }
5582 
5583     static short[] sliceBinary(short[] a, short[] b, int origin, int idx) {
5584         short[] res = new short[SPECIES.length()];
5585         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5586             if(i+origin < SPECIES.length())
5587                 res[i] = a[idx+i+origin];
5588             else {
5589                 res[i] = b[idx+j];
5590                 j++;
5591             }
5592         }
5593         return res;
5594     }
5595 
5596     @Test(dataProvider = "shortBinaryOpProvider")
5597     static void sliceBinaryShort512VectorTestsBinary(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5598         short[] a = fa.apply(SPECIES.length());
5599         short[] b = fb.apply(SPECIES.length());
5600         short[] r = new short[a.length];
5601         int origin = RAND.nextInt(SPECIES.length());
5602         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5603             for (int i = 0; i < a.length; i += SPECIES.length()) {
5604                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5605                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5606                 av.slice(origin, bv).intoArray(r, i);
5607             }
5608         }
5609 
5610         assertArraysEquals(r, a, b, origin, Short512VectorTests::sliceBinary);
5611     }
5612 
5613     static short[] slice(short[] a, short[] b, int origin, boolean[] mask, int idx) {
5614         short[] res = new short[SPECIES.length()];
5615         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5616             if(i+origin < SPECIES.length())
5617                 res[i] = mask[i] ? a[idx+i+origin] : (short)0;
5618             else {
5619                 res[i] = mask[i] ? b[idx+j] : (short)0;
5620                 j++;
5621             }
5622         }
5623         return res;
5624     }
5625 
5626     @Test(dataProvider = "shortBinaryOpMaskProvider")
5627     static void sliceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
5628     IntFunction<boolean[]> fm) {
5629         short[] a = fa.apply(SPECIES.length());
5630         short[] b = fb.apply(SPECIES.length());
5631         boolean[] mask = fm.apply(SPECIES.length());
5632         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5633 
5634         short[] r = new short[a.length];
5635         int origin = RAND.nextInt(SPECIES.length());
5636         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5637             for (int i = 0; i < a.length; i += SPECIES.length()) {
5638                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5639                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5640                 av.slice(origin, bv, vmask).intoArray(r, i);
5641             }
5642         }
5643 
5644         assertArraysEquals(r, a, b, origin, mask, Short512VectorTests::slice);
5645     }
5646 
5647     static short[] unsliceUnary(short[] a, int origin, int idx) {
5648         short[] res = new short[SPECIES.length()];
5649         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5650             if(i < origin)
5651                 res[i] = (short)0;
5652             else {
5653                 res[i] = a[idx+j];
5654                 j++;
5655             }
5656         }
5657         return res;
5658     }
5659 
5660     @Test(dataProvider = "shortUnaryOpProvider")
5661     static void unsliceUnaryShort512VectorTests(IntFunction<short[]> fa) {
5662         short[] a = fa.apply(SPECIES.length());
5663         short[] r = new short[a.length];
5664         int origin = RAND.nextInt(SPECIES.length());
5665         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5666             for (int i = 0; i < a.length; i += SPECIES.length()) {
5667                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5668                 av.unslice(origin).intoArray(r, i);
5669             }
5670         }
5671 
5672         assertArraysEquals(r, a, origin, Short512VectorTests::unsliceUnary);
5673     }
5674 
5675     static short[] unsliceBinary(short[] a, short[] b, int origin, int part, int idx) {
5676         short[] res = new short[SPECIES.length()];
5677         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5678             if (part == 0) {
5679                 if (i < origin)
5680                     res[i] = b[idx+i];
5681                 else {
5682                     res[i] = a[idx+j];
5683                     j++;
5684                 }
5685             } else if (part == 1) {
5686                 if (i < origin)
5687                     res[i] = a[idx+SPECIES.length()-origin+i];
5688                 else {
5689                     res[i] = b[idx+origin+j];
5690                     j++;
5691                 }
5692             }
5693         }
5694         return res;
5695     }
5696 
5697     @Test(dataProvider = "shortBinaryOpProvider")
5698     static void unsliceBinaryShort512VectorTestsBinary(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5699         short[] a = fa.apply(SPECIES.length());
5700         short[] b = fb.apply(SPECIES.length());
5701         short[] r = new short[a.length];
5702         int origin = RAND.nextInt(SPECIES.length());
5703         int part = RAND.nextInt(2);
5704         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5705             for (int i = 0; i < a.length; i += SPECIES.length()) {
5706                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5707                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5708                 av.unslice(origin, bv, part).intoArray(r, i);
5709             }
5710         }
5711 
5712         assertArraysEquals(r, a, b, origin, part, Short512VectorTests::unsliceBinary);
5713     }
5714 
5715     static short[] unslice(short[] a, short[] b, int origin, int part, boolean[] mask, int idx) {
5716         short[] res = new short[SPECIES.length()];
5717         for (int i = 0, j = 0; i < SPECIES.length(); i++){
5718             if(i+origin < SPECIES.length())
5719                 res[i] = b[idx+i+origin];
5720             else {
5721                 res[i] = b[idx+j];
5722                 j++;
5723             }
5724         }
5725         for (int i = 0; i < SPECIES.length(); i++){
5726             res[i] = mask[i] ? a[idx+i] : res[i];
5727         }
5728         short[] res1 = new short[SPECIES.length()];
5729         if (part == 0) {
5730             for (int i = 0, j = 0; i < SPECIES.length(); i++){
5731                 if (i < origin)
5732                     res1[i] = b[idx+i];
5733                 else {
5734                    res1[i] = res[j];
5735                    j++;
5736                 }
5737             }
5738         } else if (part == 1) {
5739             for (int i = 0, j = 0; i < SPECIES.length(); i++){
5740                 if (i < origin)
5741                     res1[i] = res[SPECIES.length()-origin+i];
5742                 else {
5743                     res1[i] = b[idx+origin+j];
5744                     j++;
5745                 }
5746             }
5747         }
5748         return res1;
5749     }
5750 
5751     @Test(dataProvider = "shortBinaryOpMaskProvider")
5752     static void unsliceShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
5753     IntFunction<boolean[]> fm) {
5754         short[] a = fa.apply(SPECIES.length());
5755         short[] b = fb.apply(SPECIES.length());
5756         boolean[] mask = fm.apply(SPECIES.length());
5757         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5758         short[] r = new short[a.length];
5759         int origin = RAND.nextInt(SPECIES.length());
5760         int part = RAND.nextInt(2);
5761         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5762             for (int i = 0; i < a.length; i += SPECIES.length()) {
5763                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5764                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5765                 av.unslice(origin, bv, part, vmask).intoArray(r, i);
5766             }
5767         }
5768 
5769         assertArraysEquals(r, a, b, origin, part, mask, Short512VectorTests::unslice);
5770     }
5771 
5772     static short BITWISE_BLEND(short a, short b, short c) {
5773         return (short)((a&~(c))|(b&c));
5774     }
5775 
5776     static short bitwiseBlend(short a, short b, short c) {
5777         return (short)((a&~(c))|(b&c));
5778     }
5779 
5780     @Test(dataProvider = "shortTernaryOpProvider")
5781     static void BITWISE_BLENDShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5782         short[] a = fa.apply(SPECIES.length());
5783         short[] b = fb.apply(SPECIES.length());
5784         short[] c = fc.apply(SPECIES.length());
5785         short[] r = fr.apply(SPECIES.length());
5786 
5787         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5788             for (int i = 0; i < a.length; i += SPECIES.length()) {
5789                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5790                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5791                 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5792                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
5793             }
5794         }
5795 
5796         assertArraysEquals(r, a, b, c, Short512VectorTests::BITWISE_BLEND);
5797     }
5798 
5799     @Test(dataProvider = "shortTernaryOpProvider")
5800     static void bitwiseBlendShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5801         short[] a = fa.apply(SPECIES.length());
5802         short[] b = fb.apply(SPECIES.length());
5803         short[] c = fc.apply(SPECIES.length());
5804         short[] r = fr.apply(SPECIES.length());
5805 
5806         for (int i = 0; i < a.length; i += SPECIES.length()) {
5807             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5808             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5809             ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5810             av.bitwiseBlend(bv, cv).intoArray(r, i);
5811         }
5812 
5813         assertArraysEquals(r, a, b, c, Short512VectorTests::bitwiseBlend);
5814     }
5815 
5816     @Test(dataProvider = "shortTernaryOpMaskProvider")
5817     static void BITWISE_BLENDShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
5818                                           IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5819         short[] a = fa.apply(SPECIES.length());
5820         short[] b = fb.apply(SPECIES.length());
5821         short[] c = fc.apply(SPECIES.length());
5822         short[] r = fr.apply(SPECIES.length());
5823         boolean[] mask = fm.apply(SPECIES.length());
5824         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5825 
5826         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5827             for (int i = 0; i < a.length; i += SPECIES.length()) {
5828                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5829                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5830                 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5831                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
5832             }
5833         }
5834 
5835         assertArraysEquals(r, a, b, c, mask, Short512VectorTests::BITWISE_BLEND);
5836     }
5837 
5838     @Test(dataProvider = "shortTernaryOpProvider")
5839     static void BITWISE_BLENDShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5840         short[] a = fa.apply(SPECIES.length());
5841         short[] b = fb.apply(SPECIES.length());
5842         short[] c = fc.apply(SPECIES.length());
5843         short[] r = fr.apply(SPECIES.length());
5844 
5845         for (int i = 0; i < a.length; i += SPECIES.length()) {
5846             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5847             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5848             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
5849         }
5850         assertBroadcastArraysEquals(r, a, b, c, Short512VectorTests::BITWISE_BLEND);
5851     }
5852 
5853     @Test(dataProvider = "shortTernaryOpProvider")
5854     static void BITWISE_BLENDShort512VectorTestsAltBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5855         short[] a = fa.apply(SPECIES.length());
5856         short[] b = fb.apply(SPECIES.length());
5857         short[] c = fc.apply(SPECIES.length());
5858         short[] r = fr.apply(SPECIES.length());
5859 
5860         for (int i = 0; i < a.length; i += SPECIES.length()) {
5861             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5862             ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5863             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
5864         }
5865         assertAltBroadcastArraysEquals(r, a, b, c, Short512VectorTests::BITWISE_BLEND);
5866     }
5867 
5868     @Test(dataProvider = "shortTernaryOpProvider")
5869     static void bitwiseBlendShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5870         short[] a = fa.apply(SPECIES.length());
5871         short[] b = fb.apply(SPECIES.length());
5872         short[] c = fc.apply(SPECIES.length());
5873         short[] r = fr.apply(SPECIES.length());
5874 
5875         for (int i = 0; i < a.length; i += SPECIES.length()) {
5876             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5877             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5878             av.bitwiseBlend(bv, c[i]).intoArray(r, i);
5879         }
5880         assertBroadcastArraysEquals(r, a, b, c, Short512VectorTests::bitwiseBlend);
5881     }
5882 
5883     @Test(dataProvider = "shortTernaryOpProvider")
5884     static void bitwiseBlendShort512VectorTestsAltBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5885         short[] a = fa.apply(SPECIES.length());
5886         short[] b = fb.apply(SPECIES.length());
5887         short[] c = fc.apply(SPECIES.length());
5888         short[] r = fr.apply(SPECIES.length());
5889 
5890         for (int i = 0; i < a.length; i += SPECIES.length()) {
5891             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5892             ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5893             av.bitwiseBlend(b[i], cv).intoArray(r, i);
5894         }
5895         assertAltBroadcastArraysEquals(r, a, b, c, Short512VectorTests::bitwiseBlend);
5896     }
5897 
5898     @Test(dataProvider = "shortTernaryOpMaskProvider")
5899     static void BITWISE_BLENDShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5900                                           IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5901         short[] a = fa.apply(SPECIES.length());
5902         short[] b = fb.apply(SPECIES.length());
5903         short[] c = fc.apply(SPECIES.length());
5904         short[] r = fr.apply(SPECIES.length());
5905         boolean[] mask = fm.apply(SPECIES.length());
5906         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5907 
5908         for (int i = 0; i < a.length; i += SPECIES.length()) {
5909             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5910             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5911             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
5912         }
5913 
5914         assertBroadcastArraysEquals(r, a, b, c, mask, Short512VectorTests::BITWISE_BLEND);
5915     }
5916 
5917     @Test(dataProvider = "shortTernaryOpMaskProvider")
5918     static void BITWISE_BLENDShort512VectorTestsAltBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5919                                           IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5920         short[] a = fa.apply(SPECIES.length());
5921         short[] b = fb.apply(SPECIES.length());
5922         short[] c = fc.apply(SPECIES.length());
5923         short[] r = fr.apply(SPECIES.length());
5924         boolean[] mask = fm.apply(SPECIES.length());
5925         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5926 
5927         for (int i = 0; i < a.length; i += SPECIES.length()) {
5928             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5929             ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5930             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
5931         }
5932 
5933         assertAltBroadcastArraysEquals(r, a, b, c, mask, Short512VectorTests::BITWISE_BLEND);
5934     }
5935 
5936     @Test(dataProvider = "shortTernaryOpProvider")
5937     static void BITWISE_BLENDShort512VectorTestsDoubleBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5938         short[] a = fa.apply(SPECIES.length());
5939         short[] b = fb.apply(SPECIES.length());
5940         short[] c = fc.apply(SPECIES.length());
5941         short[] r = fr.apply(SPECIES.length());
5942 
5943         for (int i = 0; i < a.length; i += SPECIES.length()) {
5944             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5945             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
5946         }
5947 
5948         assertDoubleBroadcastArraysEquals(r, a, b, c, Short512VectorTests::BITWISE_BLEND);
5949     }
5950 
5951     @Test(dataProvider = "shortTernaryOpProvider")
5952     static void bitwiseBlendShort512VectorTestsDoubleBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5953         short[] a = fa.apply(SPECIES.length());
5954         short[] b = fb.apply(SPECIES.length());
5955         short[] c = fc.apply(SPECIES.length());
5956         short[] r = fr.apply(SPECIES.length());
5957 
5958         for (int i = 0; i < a.length; i += SPECIES.length()) {
5959             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5960             av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
5961         }
5962 
5963         assertDoubleBroadcastArraysEquals(r, a, b, c, Short512VectorTests::bitwiseBlend);
5964     }
5965 
5966     @Test(dataProvider = "shortTernaryOpMaskProvider")
5967     static void BITWISE_BLENDShort512VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5968                                           IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5969         short[] a = fa.apply(SPECIES.length());
5970         short[] b = fb.apply(SPECIES.length());
5971         short[] c = fc.apply(SPECIES.length());
5972         short[] r = fr.apply(SPECIES.length());
5973         boolean[] mask = fm.apply(SPECIES.length());
5974         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5975 
5976         for (int i = 0; i < a.length; i += SPECIES.length()) {
5977             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5978             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
5979         }
5980 
5981         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Short512VectorTests::BITWISE_BLEND);
5982     }
5983 
5984     static short NEG(short a) {
5985         return (short)(-((short)a));
5986     }
5987 
5988     static short neg(short a) {
5989         return (short)(-((short)a));
5990     }
5991 
5992     @Test(dataProvider = "shortUnaryOpProvider")
5993     static void NEGShort512VectorTests(IntFunction<short[]> fa) {
5994         short[] a = fa.apply(SPECIES.length());
5995         short[] r = fr.apply(SPECIES.length());
5996 
5997         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5998             for (int i = 0; i < a.length; i += SPECIES.length()) {
5999                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6000                 av.lanewise(VectorOperators.NEG).intoArray(r, i);
6001             }
6002         }
6003 
6004         assertArraysEquals(r, a, Short512VectorTests::NEG);
6005     }
6006 
6007     @Test(dataProvider = "shortUnaryOpProvider")
6008     static void negShort512VectorTests(IntFunction<short[]> fa) {
6009         short[] a = fa.apply(SPECIES.length());
6010         short[] r = fr.apply(SPECIES.length());
6011 
6012         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6013             for (int i = 0; i < a.length; i += SPECIES.length()) {
6014                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6015                 av.neg().intoArray(r, i);
6016             }
6017         }
6018 
6019         assertArraysEquals(r, a, Short512VectorTests::neg);
6020     }
6021 
6022     @Test(dataProvider = "shortUnaryOpMaskProvider")
6023     static void NEGMaskedShort512VectorTests(IntFunction<short[]> fa,
6024                                                 IntFunction<boolean[]> fm) {
6025         short[] a = fa.apply(SPECIES.length());
6026         short[] r = fr.apply(SPECIES.length());
6027         boolean[] mask = fm.apply(SPECIES.length());
6028         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6029 
6030         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6031             for (int i = 0; i < a.length; i += SPECIES.length()) {
6032                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6033                 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
6034             }
6035         }
6036 
6037         assertArraysEquals(r, a, mask, Short512VectorTests::NEG);
6038     }
6039 
6040     static short ABS(short a) {
6041         return (short)(Math.abs((short)a));
6042     }
6043 
6044     static short abs(short a) {
6045         return (short)(Math.abs((short)a));
6046     }
6047 
6048     @Test(dataProvider = "shortUnaryOpProvider")
6049     static void ABSShort512VectorTests(IntFunction<short[]> fa) {
6050         short[] a = fa.apply(SPECIES.length());
6051         short[] r = fr.apply(SPECIES.length());
6052 
6053         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6054             for (int i = 0; i < a.length; i += SPECIES.length()) {
6055                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6056                 av.lanewise(VectorOperators.ABS).intoArray(r, i);
6057             }
6058         }
6059 
6060         assertArraysEquals(r, a, Short512VectorTests::ABS);
6061     }
6062 
6063     @Test(dataProvider = "shortUnaryOpProvider")
6064     static void absShort512VectorTests(IntFunction<short[]> fa) {
6065         short[] a = fa.apply(SPECIES.length());
6066         short[] r = fr.apply(SPECIES.length());
6067 
6068         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6069             for (int i = 0; i < a.length; i += SPECIES.length()) {
6070                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6071                 av.abs().intoArray(r, i);
6072             }
6073         }
6074 
6075         assertArraysEquals(r, a, Short512VectorTests::abs);
6076     }
6077 
6078     @Test(dataProvider = "shortUnaryOpMaskProvider")
6079     static void ABSMaskedShort512VectorTests(IntFunction<short[]> fa,
6080                                                 IntFunction<boolean[]> fm) {
6081         short[] a = fa.apply(SPECIES.length());
6082         short[] r = fr.apply(SPECIES.length());
6083         boolean[] mask = fm.apply(SPECIES.length());
6084         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6085 
6086         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6087             for (int i = 0; i < a.length; i += SPECIES.length()) {
6088                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6089                 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
6090             }
6091         }
6092 
6093         assertArraysEquals(r, a, mask, Short512VectorTests::ABS);
6094     }
6095 
6096     static short NOT(short a) {
6097         return (short)(~((short)a));
6098     }
6099 
6100     static short not(short a) {
6101         return (short)(~((short)a));
6102     }
6103 
6104     @Test(dataProvider = "shortUnaryOpProvider")
6105     static void NOTShort512VectorTests(IntFunction<short[]> fa) {
6106         short[] a = fa.apply(SPECIES.length());
6107         short[] r = fr.apply(SPECIES.length());
6108 
6109         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6110             for (int i = 0; i < a.length; i += SPECIES.length()) {
6111                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6112                 av.lanewise(VectorOperators.NOT).intoArray(r, i);
6113             }
6114         }
6115 
6116         assertArraysEquals(r, a, Short512VectorTests::NOT);
6117     }
6118 
6119     @Test(dataProvider = "shortUnaryOpProvider")
6120     static void notShort512VectorTests(IntFunction<short[]> fa) {
6121         short[] a = fa.apply(SPECIES.length());
6122         short[] r = fr.apply(SPECIES.length());
6123 
6124         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6125             for (int i = 0; i < a.length; i += SPECIES.length()) {
6126                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6127                 av.not().intoArray(r, i);
6128             }
6129         }
6130 
6131         assertArraysEquals(r, a, Short512VectorTests::not);
6132     }
6133 
6134     @Test(dataProvider = "shortUnaryOpMaskProvider")
6135     static void NOTMaskedShort512VectorTests(IntFunction<short[]> fa,
6136                                                 IntFunction<boolean[]> fm) {
6137         short[] a = fa.apply(SPECIES.length());
6138         short[] r = fr.apply(SPECIES.length());
6139         boolean[] mask = fm.apply(SPECIES.length());
6140         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6141 
6142         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6143             for (int i = 0; i < a.length; i += SPECIES.length()) {
6144                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6145                 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
6146             }
6147         }
6148 
6149         assertArraysEquals(r, a, mask, Short512VectorTests::NOT);
6150     }
6151 
6152     static short ZOMO(short a) {
6153         return (short)((a==0?0:-1));
6154     }
6155 
6156     @Test(dataProvider = "shortUnaryOpProvider")
6157     static void ZOMOShort512VectorTests(IntFunction<short[]> fa) {
6158         short[] a = fa.apply(SPECIES.length());
6159         short[] r = fr.apply(SPECIES.length());
6160 
6161         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6162             for (int i = 0; i < a.length; i += SPECIES.length()) {
6163                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6164                 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
6165             }
6166         }
6167 
6168         assertArraysEquals(r, a, Short512VectorTests::ZOMO);
6169     }
6170 
6171     @Test(dataProvider = "shortUnaryOpMaskProvider")
6172     static void ZOMOMaskedShort512VectorTests(IntFunction<short[]> fa,
6173                                                 IntFunction<boolean[]> fm) {
6174         short[] a = fa.apply(SPECIES.length());
6175         short[] r = fr.apply(SPECIES.length());
6176         boolean[] mask = fm.apply(SPECIES.length());
6177         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6178 
6179         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6180             for (int i = 0; i < a.length; i += SPECIES.length()) {
6181                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6182                 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
6183             }
6184         }
6185 
6186         assertArraysEquals(r, a, mask, Short512VectorTests::ZOMO);
6187     }
6188 
6189     static short BIT_COUNT(short a) {
6190         return (short)(Integer.bitCount((int)a & 0xFFFF));
6191     }
6192 
6193     @Test(dataProvider = "shortUnaryOpProvider")
6194     static void BIT_COUNTShort512VectorTests(IntFunction<short[]> fa) {
6195         short[] a = fa.apply(SPECIES.length());
6196         short[] r = fr.apply(SPECIES.length());
6197 
6198         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6199             for (int i = 0; i < a.length; i += SPECIES.length()) {
6200                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6201                 av.lanewise(VectorOperators.BIT_COUNT).intoArray(r, i);
6202             }
6203         }
6204 
6205         assertArraysEquals(r, a, Short512VectorTests::BIT_COUNT);
6206     }
6207 
6208     @Test(dataProvider = "shortUnaryOpMaskProvider")
6209     static void BIT_COUNTMaskedShort512VectorTests(IntFunction<short[]> fa,
6210                                                 IntFunction<boolean[]> fm) {
6211         short[] a = fa.apply(SPECIES.length());
6212         short[] r = fr.apply(SPECIES.length());
6213         boolean[] mask = fm.apply(SPECIES.length());
6214         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6215 
6216         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6217             for (int i = 0; i < a.length; i += SPECIES.length()) {
6218                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6219                 av.lanewise(VectorOperators.BIT_COUNT, vmask).intoArray(r, i);
6220             }
6221         }
6222 
6223         assertArraysEquals(r, a, mask, Short512VectorTests::BIT_COUNT);
6224     }
6225 
6226     static short TRAILING_ZEROS_COUNT(short a) {
6227         return (short)(TRAILING_ZEROS_COUNT_scalar(a));
6228     }
6229 
6230     @Test(dataProvider = "shortUnaryOpProvider")
6231     static void TRAILING_ZEROS_COUNTShort512VectorTests(IntFunction<short[]> fa) {
6232         short[] a = fa.apply(SPECIES.length());
6233         short[] r = fr.apply(SPECIES.length());
6234 
6235         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6236             for (int i = 0; i < a.length; i += SPECIES.length()) {
6237                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6238                 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT).intoArray(r, i);
6239             }
6240         }
6241 
6242         assertArraysEquals(r, a, Short512VectorTests::TRAILING_ZEROS_COUNT);
6243     }
6244 
6245     @Test(dataProvider = "shortUnaryOpMaskProvider")
6246     static void TRAILING_ZEROS_COUNTMaskedShort512VectorTests(IntFunction<short[]> fa,
6247                                                 IntFunction<boolean[]> fm) {
6248         short[] a = fa.apply(SPECIES.length());
6249         short[] r = fr.apply(SPECIES.length());
6250         boolean[] mask = fm.apply(SPECIES.length());
6251         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6252 
6253         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6254             for (int i = 0; i < a.length; i += SPECIES.length()) {
6255                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6256                 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT, vmask).intoArray(r, i);
6257             }
6258         }
6259 
6260         assertArraysEquals(r, a, mask, Short512VectorTests::TRAILING_ZEROS_COUNT);
6261     }
6262 
6263     static short LEADING_ZEROS_COUNT(short a) {
6264         return (short)(LEADING_ZEROS_COUNT_scalar(a));
6265     }
6266 
6267     @Test(dataProvider = "shortUnaryOpProvider")
6268     static void LEADING_ZEROS_COUNTShort512VectorTests(IntFunction<short[]> fa) {
6269         short[] a = fa.apply(SPECIES.length());
6270         short[] r = fr.apply(SPECIES.length());
6271 
6272         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6273             for (int i = 0; i < a.length; i += SPECIES.length()) {
6274                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6275                 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT).intoArray(r, i);
6276             }
6277         }
6278 
6279         assertArraysEquals(r, a, Short512VectorTests::LEADING_ZEROS_COUNT);
6280     }
6281 
6282     @Test(dataProvider = "shortUnaryOpMaskProvider")
6283     static void LEADING_ZEROS_COUNTMaskedShort512VectorTests(IntFunction<short[]> fa,
6284                                                 IntFunction<boolean[]> fm) {
6285         short[] a = fa.apply(SPECIES.length());
6286         short[] r = fr.apply(SPECIES.length());
6287         boolean[] mask = fm.apply(SPECIES.length());
6288         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6289 
6290         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6291             for (int i = 0; i < a.length; i += SPECIES.length()) {
6292                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6293                 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT, vmask).intoArray(r, i);
6294             }
6295         }
6296 
6297         assertArraysEquals(r, a, mask, Short512VectorTests::LEADING_ZEROS_COUNT);
6298     }
6299 
6300     static short REVERSE(short a) {
6301         return (short)(REVERSE_scalar(a));
6302     }
6303 
6304     @Test(dataProvider = "shortUnaryOpProvider")
6305     static void REVERSEShort512VectorTests(IntFunction<short[]> fa) {
6306         short[] a = fa.apply(SPECIES.length());
6307         short[] r = fr.apply(SPECIES.length());
6308 
6309         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6310             for (int i = 0; i < a.length; i += SPECIES.length()) {
6311                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6312                 av.lanewise(VectorOperators.REVERSE).intoArray(r, i);
6313             }
6314         }
6315 
6316         assertArraysEquals(r, a, Short512VectorTests::REVERSE);
6317     }
6318 
6319     @Test(dataProvider = "shortUnaryOpMaskProvider")
6320     static void REVERSEMaskedShort512VectorTests(IntFunction<short[]> fa,
6321                                                 IntFunction<boolean[]> fm) {
6322         short[] a = fa.apply(SPECIES.length());
6323         short[] r = fr.apply(SPECIES.length());
6324         boolean[] mask = fm.apply(SPECIES.length());
6325         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6326 
6327         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6328             for (int i = 0; i < a.length; i += SPECIES.length()) {
6329                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6330                 av.lanewise(VectorOperators.REVERSE, vmask).intoArray(r, i);
6331             }
6332         }
6333 
6334         assertArraysEquals(r, a, mask, Short512VectorTests::REVERSE);
6335     }
6336 
6337     static short REVERSE_BYTES(short a) {
6338         return (short)(Short.reverseBytes(a));
6339     }
6340 
6341     @Test(dataProvider = "shortUnaryOpProvider")
6342     static void REVERSE_BYTESShort512VectorTests(IntFunction<short[]> fa) {
6343         short[] a = fa.apply(SPECIES.length());
6344         short[] r = fr.apply(SPECIES.length());
6345 
6346         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6347             for (int i = 0; i < a.length; i += SPECIES.length()) {
6348                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6349                 av.lanewise(VectorOperators.REVERSE_BYTES).intoArray(r, i);
6350             }
6351         }
6352 
6353         assertArraysEquals(r, a, Short512VectorTests::REVERSE_BYTES);
6354     }
6355 
6356     @Test(dataProvider = "shortUnaryOpMaskProvider")
6357     static void REVERSE_BYTESMaskedShort512VectorTests(IntFunction<short[]> fa,
6358                                                 IntFunction<boolean[]> fm) {
6359         short[] a = fa.apply(SPECIES.length());
6360         short[] r = fr.apply(SPECIES.length());
6361         boolean[] mask = fm.apply(SPECIES.length());
6362         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6363 
6364         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6365             for (int i = 0; i < a.length; i += SPECIES.length()) {
6366                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6367                 av.lanewise(VectorOperators.REVERSE_BYTES, vmask).intoArray(r, i);
6368             }
6369         }
6370 
6371         assertArraysEquals(r, a, mask, Short512VectorTests::REVERSE_BYTES);
6372     }
6373 
6374     @Test(dataProvider = "shortCompareOpProvider")
6375     static void ltShort512VectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
6376         short[] a = fa.apply(SPECIES.length());
6377         short[] b = fb.apply(SPECIES.length());
6378 
6379         for (int i = 0; i < a.length; i += SPECIES.length()) {
6380             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6381             VectorMask<Short> mv = av.lt(b[i]);
6382 
6383             // Check results as part of computation.
6384             for (int j = 0; j < SPECIES.length(); j++) {
6385                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
6386             }
6387         }
6388     }
6389 
6390     @Test(dataProvider = "shortCompareOpProvider")
6391     static void eqShort512VectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
6392         short[] a = fa.apply(SPECIES.length());
6393         short[] b = fb.apply(SPECIES.length());
6394 
6395         for (int i = 0; i < a.length; i += SPECIES.length()) {
6396             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6397             VectorMask<Short> mv = av.eq(b[i]);
6398 
6399             // Check results as part of computation.
6400             for (int j = 0; j < SPECIES.length(); j++) {
6401                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
6402             }
6403         }
6404     }
6405 
6406     @Test(dataProvider = "shortUnaryOpProvider")
6407     static void toIntArrayShort512VectorTestsSmokeTest(IntFunction<short[]> fa) {
6408         short[] a = fa.apply(SPECIES.length());
6409 
6410         for (int i = 0; i < a.length; i += SPECIES.length()) {
6411             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6412             int[] r = av.toIntArray();
6413             assertArraysEquals(r, a, i);
6414         }
6415     }
6416 
6417     @Test(dataProvider = "shortUnaryOpProvider")
6418     static void toLongArrayShort512VectorTestsSmokeTest(IntFunction<short[]> fa) {
6419         short[] a = fa.apply(SPECIES.length());
6420 
6421         for (int i = 0; i < a.length; i += SPECIES.length()) {
6422             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6423             long[] r = av.toLongArray();
6424             assertArraysEquals(r, a, i);
6425         }
6426     }
6427 
6428     @Test(dataProvider = "shortUnaryOpProvider")
6429     static void toDoubleArrayShort512VectorTestsSmokeTest(IntFunction<short[]> fa) {
6430         short[] a = fa.apply(SPECIES.length());
6431 
6432         for (int i = 0; i < a.length; i += SPECIES.length()) {
6433             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6434             double[] r = av.toDoubleArray();
6435             assertArraysEquals(r, a, i);
6436         }
6437     }
6438 
6439     @Test(dataProvider = "shortUnaryOpProvider")
6440     static void toStringShort512VectorTestsSmokeTest(IntFunction<short[]> fa) {
6441         short[] a = fa.apply(SPECIES.length());
6442 
6443         for (int i = 0; i < a.length; i += SPECIES.length()) {
6444             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6445             String str = av.toString();
6446 
6447             short subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6448             Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
6449         }
6450     }
6451 
6452     @Test(dataProvider = "shortUnaryOpProvider")
6453     static void hashCodeShort512VectorTestsSmokeTest(IntFunction<short[]> fa) {
6454         short[] a = fa.apply(SPECIES.length());
6455 
6456         for (int i = 0; i < a.length; i += SPECIES.length()) {
6457             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6458             int hash = av.hashCode();
6459 
6460             short subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6461             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6462             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6463         }
6464     }
6465 
6466 
6467     static long ADDReduceLong(short[] a, int idx) {
6468         short res = 0;
6469         for (int i = idx; i < (idx + SPECIES.length()); i++) {
6470             res += a[i];
6471         }
6472 
6473         return (long)res;
6474     }
6475 
6476     static long ADDReduceAllLong(short[] a) {
6477         long res = 0;
6478         for (int i = 0; i < a.length; i += SPECIES.length()) {
6479             res += ADDReduceLong(a, i);
6480         }
6481 
6482         return res;
6483     }
6484 
6485     @Test(dataProvider = "shortUnaryOpProvider")
6486     static void ADDReduceLongShort512VectorTests(IntFunction<short[]> fa) {
6487         short[] a = fa.apply(SPECIES.length());
6488         long[] r = lfr.apply(SPECIES.length());
6489         long ra = 0;
6490 
6491         for (int i = 0; i < a.length; i += SPECIES.length()) {
6492             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6493             r[i] = av.reduceLanesToLong(VectorOperators.ADD);
6494         }
6495 
6496         ra = 0;
6497         for (int i = 0; i < a.length; i ++) {
6498             ra += r[i];
6499         }
6500 
6501         assertReductionLongArraysEquals(r, ra, a,
6502                 Short512VectorTests::ADDReduceLong, Short512VectorTests::ADDReduceAllLong);
6503     }
6504 
6505     static long ADDReduceLongMasked(short[] a, int idx, boolean[] mask) {
6506         short res = 0;
6507         for (int i = idx; i < (idx + SPECIES.length()); i++) {
6508             if(mask[i % SPECIES.length()])
6509                 res += a[i];
6510         }
6511 
6512         return (long)res;
6513     }
6514 
6515     static long ADDReduceAllLongMasked(short[] a, boolean[] mask) {
6516         long res = 0;
6517         for (int i = 0; i < a.length; i += SPECIES.length()) {
6518             res += ADDReduceLongMasked(a, i, mask);
6519         }
6520 
6521         return res;
6522     }
6523 
6524     @Test(dataProvider = "shortUnaryOpMaskProvider")
6525     static void ADDReduceLongShort512VectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
6526         short[] a = fa.apply(SPECIES.length());
6527         long[] r = lfr.apply(SPECIES.length());
6528         boolean[] mask = fm.apply(SPECIES.length());
6529         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6530         long ra = 0;
6531 
6532         for (int i = 0; i < a.length; i += SPECIES.length()) {
6533             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6534             r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
6535         }
6536 
6537         ra = 0;
6538         for (int i = 0; i < a.length; i ++) {
6539             ra += r[i];
6540         }
6541 
6542         assertReductionLongArraysEqualsMasked(r, ra, a, mask,
6543                 Short512VectorTests::ADDReduceLongMasked, Short512VectorTests::ADDReduceAllLongMasked);
6544     }
6545 
6546     @Test(dataProvider = "shortUnaryOpProvider")
6547     static void BroadcastLongShort512VectorTestsSmokeTest(IntFunction<short[]> fa) {
6548         short[] a = fa.apply(SPECIES.length());
6549         short[] r = new short[a.length];
6550 
6551         for (int i = 0; i < a.length; i += SPECIES.length()) {
6552             ShortVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
6553         }
6554         assertBroadcastArraysEquals(r, a);
6555     }
6556 
6557     @Test(dataProvider = "shortBinaryOpMaskProvider")
6558     static void blendShort512VectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
6559                                           IntFunction<boolean[]> fm) {
6560         short[] a = fa.apply(SPECIES.length());
6561         short[] b = fb.apply(SPECIES.length());
6562         short[] r = fr.apply(SPECIES.length());
6563         boolean[] mask = fm.apply(SPECIES.length());
6564         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6565 
6566         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6567             for (int i = 0; i < a.length; i += SPECIES.length()) {
6568                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6569                 av.blend((long)b[i], vmask).intoArray(r, i);
6570             }
6571         }
6572         assertBroadcastLongArraysEquals(r, a, b, mask, Short512VectorTests::blend);
6573     }
6574 
6575 
6576     @Test(dataProvider = "shortUnaryOpSelectFromProvider")
6577     static void SelectFromShort512VectorTests(IntFunction<short[]> fa,
6578                                            BiFunction<Integer,Integer,short[]> fs) {
6579         short[] a = fa.apply(SPECIES.length());
6580         short[] order = fs.apply(a.length, SPECIES.length());
6581         short[] r = fr.apply(SPECIES.length());
6582 
6583         for (int i = 0; i < a.length; i += SPECIES.length()) {
6584             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6585             ShortVector bv = ShortVector.fromArray(SPECIES, order, i);
6586             bv.selectFrom(av).intoArray(r, i);
6587         }
6588 
6589         assertSelectFromArraysEquals(r, a, order, SPECIES.length());
6590     }
6591 
6592     @Test(dataProvider = "shortSelectFromTwoVectorOpProvider")
6593     static void SelectFromTwoVectorShort512VectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
6594         short[] a = fa.apply(SPECIES.length());
6595         short[] b = fb.apply(SPECIES.length());
6596         short[] idx = fc.apply(SPECIES.length());
6597         short[] r = fr.apply(SPECIES.length());
6598 
6599         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6600             for (int i = 0; i < idx.length; i += SPECIES.length()) {
6601                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6602                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
6603                 ShortVector idxv = ShortVector.fromArray(SPECIES, idx, i);
6604                 idxv.selectFrom(av, bv).intoArray(r, i);
6605             }
6606         }
6607         assertSelectFromTwoVectorEquals(r, idx, a, b, SPECIES.length());
6608     }
6609 
6610     @Test(dataProvider = "shortUnaryOpSelectFromMaskProvider")
6611     static void SelectFromShort512VectorTestsMaskedSmokeTest(IntFunction<short[]> fa,
6612                                                            BiFunction<Integer,Integer,short[]> fs,
6613                                                            IntFunction<boolean[]> fm) {
6614         short[] a = fa.apply(SPECIES.length());
6615         short[] order = fs.apply(a.length, SPECIES.length());
6616         short[] r = fr.apply(SPECIES.length());
6617         boolean[] mask = fm.apply(SPECIES.length());
6618         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6619 
6620         for (int i = 0; i < a.length; i += SPECIES.length()) {
6621             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
6622             ShortVector bv = ShortVector.fromArray(SPECIES, order, i);
6623             bv.selectFrom(av, vmask).intoArray(r, i);
6624         }
6625 
6626         assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
6627     }
6628 
6629     @Test(dataProvider = "shuffleProvider")
6630     static void shuffleMiscellaneousShort512VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
6631         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6632 
6633         for (int i = 0; i < a.length; i += SPECIES.length()) {
6634             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
6635             int hash = shuffle.hashCode();
6636             int length = shuffle.length();
6637 
6638             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6639             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6640             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6641             Assert.assertEquals(length, SPECIES.length());
6642         }
6643     }
6644 
6645     @Test(dataProvider = "shuffleProvider")
6646     static void shuffleToStringShort512VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
6647         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6648 
6649         for (int i = 0; i < a.length; i += SPECIES.length()) {
6650             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
6651             String str = shuffle.toString();
6652 
6653             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6654             Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
6655                 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
6656         }
6657     }
6658 
6659     @Test(dataProvider = "shuffleCompareOpProvider")
6660     static void shuffleEqualsShort512VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
6661         int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6662         int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6663 
6664         for (int i = 0; i < a.length; i += SPECIES.length()) {
6665             var av = VectorShuffle.fromArray(SPECIES, a, i);
6666             var bv = VectorShuffle.fromArray(SPECIES, b, i);
6667             boolean eq = av.equals(bv);
6668             int to = i + SPECIES.length();
6669             Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
6670         }
6671     }
6672 
6673     @Test(dataProvider = "maskCompareOpProvider")
6674     static void maskEqualsShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6675         boolean[] a = fa.apply(SPECIES.length());
6676         boolean[] b = fb.apply(SPECIES.length());
6677 
6678         for (int i = 0; i < a.length; i += SPECIES.length()) {
6679             var av = SPECIES.loadMask(a, i);
6680             var bv = SPECIES.loadMask(b, i);
6681             boolean equals = av.equals(bv);
6682             int to = i + SPECIES.length();
6683             Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
6684         }
6685     }
6686 
6687     static boolean band(boolean a, boolean b) {
6688         return a & b;
6689     }
6690 
6691     @Test(dataProvider = "maskCompareOpProvider")
6692     static void maskAndShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6693         boolean[] a = fa.apply(SPECIES.length());
6694         boolean[] b = fb.apply(SPECIES.length());
6695         boolean[] r = new boolean[a.length];
6696 
6697         for (int i = 0; i < a.length; i += SPECIES.length()) {
6698             var av = SPECIES.loadMask(a, i);
6699             var bv = SPECIES.loadMask(b, i);
6700             var cv = av.and(bv);
6701             cv.intoArray(r, i);
6702         }
6703         assertArraysEquals(r, a, b, Short512VectorTests::band);
6704     }
6705 
6706     static boolean bor(boolean a, boolean b) {
6707         return a | b;
6708     }
6709 
6710     @Test(dataProvider = "maskCompareOpProvider")
6711     static void maskOrShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6712         boolean[] a = fa.apply(SPECIES.length());
6713         boolean[] b = fb.apply(SPECIES.length());
6714         boolean[] r = new boolean[a.length];
6715 
6716         for (int i = 0; i < a.length; i += SPECIES.length()) {
6717             var av = SPECIES.loadMask(a, i);
6718             var bv = SPECIES.loadMask(b, i);
6719             var cv = av.or(bv);
6720             cv.intoArray(r, i);
6721         }
6722         assertArraysEquals(r, a, b, Short512VectorTests::bor);
6723     }
6724 
6725     static boolean bxor(boolean a, boolean b) {
6726         return a != b;
6727     }
6728 
6729     @Test(dataProvider = "maskCompareOpProvider")
6730     static void maskXorShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6731         boolean[] a = fa.apply(SPECIES.length());
6732         boolean[] b = fb.apply(SPECIES.length());
6733         boolean[] r = new boolean[a.length];
6734 
6735         for (int i = 0; i < a.length; i += SPECIES.length()) {
6736             var av = SPECIES.loadMask(a, i);
6737             var bv = SPECIES.loadMask(b, i);
6738             var cv = av.xor(bv);
6739             cv.intoArray(r, i);
6740         }
6741         assertArraysEquals(r, a, b, Short512VectorTests::bxor);
6742     }
6743 
6744     static boolean bandNot(boolean a, boolean b) {
6745         return a & !b;
6746     }
6747 
6748     @Test(dataProvider = "maskCompareOpProvider")
6749     static void maskAndNotShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6750         boolean[] a = fa.apply(SPECIES.length());
6751         boolean[] b = fb.apply(SPECIES.length());
6752         boolean[] r = new boolean[a.length];
6753 
6754         for (int i = 0; i < a.length; i += SPECIES.length()) {
6755             var av = SPECIES.loadMask(a, i);
6756             var bv = SPECIES.loadMask(b, i);
6757             var cv = av.andNot(bv);
6758             cv.intoArray(r, i);
6759         }
6760         assertArraysEquals(r, a, b, Short512VectorTests::bandNot);
6761     }
6762 
6763     static boolean beq(boolean a, boolean b) {
6764         return (a == b);
6765     }
6766 
6767     @Test(dataProvider = "maskCompareOpProvider")
6768     static void maskEqShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6769         boolean[] a = fa.apply(SPECIES.length());
6770         boolean[] b = fb.apply(SPECIES.length());
6771         boolean[] r = new boolean[a.length];
6772 
6773         for (int i = 0; i < a.length; i += SPECIES.length()) {
6774             var av = SPECIES.loadMask(a, i);
6775             var bv = SPECIES.loadMask(b, i);
6776             var cv = av.eq(bv);
6777             cv.intoArray(r, i);
6778         }
6779         assertArraysEquals(r, a, b, Short512VectorTests::beq);
6780     }
6781 
6782     @Test(dataProvider = "maskProvider")
6783     static void maskHashCodeShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6784         boolean[] a = fa.apply(SPECIES.length());
6785 
6786         for (int i = 0; i < a.length; i += SPECIES.length()) {
6787             var vmask = SPECIES.loadMask(a, i);
6788             int hash = vmask.hashCode();
6789 
6790             boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6791             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6792             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6793         }
6794     }
6795 
6796     static int maskTrueCount(boolean[] a, int idx) {
6797         int trueCount = 0;
6798         for (int i = idx; i < idx + SPECIES.length(); i++) {
6799             trueCount += a[i] ? 1 : 0;
6800         }
6801         return trueCount;
6802     }
6803 
6804     @Test(dataProvider = "maskProvider")
6805     static void maskTrueCountShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6806         boolean[] a = fa.apply(SPECIES.length());
6807         int[] r = new int[a.length];
6808 
6809         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6810             for (int i = 0; i < a.length; i += SPECIES.length()) {
6811                 var vmask = SPECIES.loadMask(a, i);
6812                 r[i] = vmask.trueCount();
6813             }
6814         }
6815 
6816         assertMaskReductionArraysEquals(r, a, Short512VectorTests::maskTrueCount);
6817     }
6818 
6819     static int maskLastTrue(boolean[] a, int idx) {
6820         int i = idx + SPECIES.length() - 1;
6821         for (; i >= idx; i--) {
6822             if (a[i]) {
6823                 break;
6824             }
6825         }
6826         return i - idx;
6827     }
6828 
6829     @Test(dataProvider = "maskProvider")
6830     static void maskLastTrueShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6831         boolean[] a = fa.apply(SPECIES.length());
6832         int[] r = new int[a.length];
6833 
6834         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6835             for (int i = 0; i < a.length; i += SPECIES.length()) {
6836                 var vmask = SPECIES.loadMask(a, i);
6837                 r[i] = vmask.lastTrue();
6838             }
6839         }
6840 
6841         assertMaskReductionArraysEquals(r, a, Short512VectorTests::maskLastTrue);
6842     }
6843 
6844     static int maskFirstTrue(boolean[] a, int idx) {
6845         int i = idx;
6846         for (; i < idx + SPECIES.length(); i++) {
6847             if (a[i]) {
6848                 break;
6849             }
6850         }
6851         return i - idx;
6852     }
6853 
6854     @Test(dataProvider = "maskProvider")
6855     static void maskFirstTrueShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6856         boolean[] a = fa.apply(SPECIES.length());
6857         int[] r = new int[a.length];
6858 
6859         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6860             for (int i = 0; i < a.length; i += SPECIES.length()) {
6861                 var vmask = SPECIES.loadMask(a, i);
6862                 r[i] = vmask.firstTrue();
6863             }
6864         }
6865 
6866         assertMaskReductionArraysEquals(r, a, Short512VectorTests::maskFirstTrue);
6867     }
6868 
6869     @Test(dataProvider = "maskProvider")
6870     static void maskCompressShort512VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6871         int trueCount = 0;
6872         boolean[] a = fa.apply(SPECIES.length());
6873 
6874         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6875             for (int i = 0; i < a.length; i += SPECIES.length()) {
6876                 var vmask = SPECIES.loadMask(a, i);
6877                 trueCount = vmask.trueCount();
6878                 var rmask = vmask.compress();
6879                 for (int j = 0; j < SPECIES.length(); j++)  {
6880                     Assert.assertEquals(rmask.laneIsSet(j), j < trueCount);
6881                 }
6882             }
6883         }
6884     }
6885 
6886     @DataProvider
6887     public static Object[][] longMaskProvider() {
6888         return new Object[][]{
6889                 {0xFFFFFFFFFFFFFFFFL},
6890                 {0x0000000000000000L},
6891                 {0x5555555555555555L},
6892                 {0x0123456789abcdefL},
6893         };
6894     }
6895 
6896     @Test(dataProvider = "longMaskProvider")
6897     static void maskFromToLongShort512VectorTestsSmokeTest(long inputLong) {
6898         var vmask = VectorMask.fromLong(SPECIES, inputLong);
6899         long outputLong = vmask.toLong();
6900         Assert.assertEquals(outputLong, (inputLong & (((0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()))))));
6901     }
6902 
6903     @DataProvider
6904     public static Object[][] offsetProvider() {
6905         return new Object[][]{
6906                 {0},
6907                 {-1},
6908                 {+1},
6909                 {+2},
6910                 {-2},
6911         };
6912     }
6913 
6914     @Test(dataProvider = "offsetProvider")
6915     static void indexInRangeShort512VectorTestsSmokeTest(int offset) {
6916         int limit = SPECIES.length() * BUFFER_REPS;
6917         for (int i = 0; i < limit; i += SPECIES.length()) {
6918             var actualMask = SPECIES.indexInRange(i + offset, limit);
6919             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
6920             assert(actualMask.equals(expectedMask));
6921             for (int j = 0; j < SPECIES.length(); j++)  {
6922                 int index = i + j + offset;
6923                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
6924             }
6925         }
6926     }
6927 
6928     @Test(dataProvider = "offsetProvider")
6929     static void indexInRangeLongShort512VectorTestsSmokeTest(int offset) {
6930         long limit = SPECIES.length() * BUFFER_REPS;
6931         for (long i = 0; i < limit; i += SPECIES.length()) {
6932             var actualMask = SPECIES.indexInRange(i + offset, limit);
6933             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
6934             assert(actualMask.equals(expectedMask));
6935             for (int j = 0; j < SPECIES.length(); j++)  {
6936                 long index = i + j + offset;
6937                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
6938             }
6939         }
6940     }
6941 
6942     @DataProvider
6943     public static Object[][] lengthProvider() {
6944         return new Object[][]{
6945                 {0},
6946                 {1},
6947                 {32},
6948                 {37},
6949                 {1024},
6950                 {1024+1},
6951                 {1024+5},
6952         };
6953     }
6954 
6955     @Test(dataProvider = "lengthProvider")
6956     static void loopBoundShort512VectorTestsSmokeTest(int length) {
6957         int actualLoopBound = SPECIES.loopBound(length);
6958         int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
6959         Assert.assertEquals(actualLoopBound, expectedLoopBound);
6960     }
6961 
6962     @Test(dataProvider = "lengthProvider")
6963     static void loopBoundLongShort512VectorTestsSmokeTest(int _length) {
6964         long length = _length;
6965         long actualLoopBound = SPECIES.loopBound(length);
6966         long expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
6967         Assert.assertEquals(actualLoopBound, expectedLoopBound);
6968     }
6969 
6970     @Test
6971     static void ElementSizeShort512VectorTestsSmokeTest() {
6972         ShortVector av = ShortVector.zero(SPECIES);
6973         int elsize = av.elementSize();
6974         Assert.assertEquals(elsize, Short.SIZE);
6975     }
6976 
6977     @Test
6978     static void VectorShapeShort512VectorTestsSmokeTest() {
6979         ShortVector av = ShortVector.zero(SPECIES);
6980         VectorShape vsh = av.shape();
6981         assert(vsh.equals(VectorShape.S_512_BIT));
6982     }
6983 
6984     @Test
6985     static void ShapeWithLanesShort512VectorTestsSmokeTest() {
6986         ShortVector av = ShortVector.zero(SPECIES);
6987         VectorShape vsh = av.shape();
6988         VectorSpecies species = vsh.withLanes(short.class);
6989         assert(species.equals(SPECIES));
6990     }
6991 
6992     @Test
6993     static void ElementTypeShort512VectorTestsSmokeTest() {
6994         ShortVector av = ShortVector.zero(SPECIES);
6995         assert(av.species().elementType() == short.class);
6996     }
6997 
6998     @Test
6999     static void SpeciesElementSizeShort512VectorTestsSmokeTest() {
7000         ShortVector av = ShortVector.zero(SPECIES);
7001         assert(av.species().elementSize() == Short.SIZE);
7002     }
7003 
7004     @Test
7005     static void VectorTypeShort512VectorTestsSmokeTest() {
7006         ShortVector av = ShortVector.zero(SPECIES);
7007         assert(av.species().vectorType() == av.getClass());
7008     }
7009 
7010     @Test
7011     static void WithLanesShort512VectorTestsSmokeTest() {
7012         ShortVector av = ShortVector.zero(SPECIES);
7013         VectorSpecies species = av.species().withLanes(short.class);
7014         assert(species.equals(SPECIES));
7015     }
7016 
7017     @Test
7018     static void WithShapeShort512VectorTestsSmokeTest() {
7019         ShortVector av = ShortVector.zero(SPECIES);
7020         VectorShape vsh = av.shape();
7021         VectorSpecies species = av.species().withShape(vsh);
7022         assert(species.equals(SPECIES));
7023     }
7024 
7025     @Test
7026     static void MaskAllTrueShort512VectorTestsSmokeTest() {
7027         for (int ic = 0; ic < INVOC_COUNT; ic++) {
7028           Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
7029         }
7030     }
7031 }