1 /*
   2  * Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @modules jdk.incubator.vector
  27  * @run testng/othervm -ea -esa -Xbatch -XX:-TieredCompilation ShortMaxVectorTests
  28  */
  29 
  30 // -- This file was mechanically generated: Do not edit! -- //
  31 
  32 import jdk.incubator.vector.VectorShape;
  33 import jdk.incubator.vector.VectorSpecies;
  34 import jdk.incubator.vector.VectorShuffle;
  35 import jdk.incubator.vector.VectorMask;
  36 import jdk.incubator.vector.VectorOperators;
  37 import jdk.incubator.vector.Vector;
  38 
  39 import jdk.incubator.vector.ShortVector;
  40 
  41 import org.testng.Assert;
  42 import org.testng.annotations.DataProvider;
  43 import org.testng.annotations.Test;
  44 
  45 import java.lang.Integer;
  46 import java.util.List;
  47 import java.util.Arrays;
  48 import java.util.function.BiFunction;
  49 import java.util.function.IntFunction;
  50 import java.util.Objects;
  51 import java.util.stream.Collectors;
  52 import java.util.stream.Stream;
  53 
  54 @Test
  55 public class ShortMaxVectorTests extends AbstractVectorTest {
  56 
  57     static final VectorSpecies<Short> SPECIES =
  58                 ShortVector.SPECIES_MAX;
  59 
  60     static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
  61 
  62     static VectorShape getMaxBit() {
  63         return VectorShape.S_Max_BIT;
  64     }
  65 
  66     private static final int Max = 256;  // juts so we can do N/Max
  67 
  68     private static final short CONST_SHIFT = Short.SIZE / 2;
  69 
  70     static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / Max);
  71 
  72     interface FUnOp {
  73         short apply(short a);
  74     }
  75 
  76     static void assertArraysEquals(short[] r, short[] a, FUnOp f) {
  77         int i = 0;
  78         try {
  79             for (; i < a.length; i++) {
  80                 Assert.assertEquals(r[i], f.apply(a[i]));
  81             }
  82         } catch (AssertionError e) {
  83             Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
  84         }
  85     }
  86 
  87     interface FUnArrayOp {
  88         short[] apply(short a);
  89     }
  90 
  91     static void assertArraysEquals(short[] r, short[] a, FUnArrayOp f) {
  92         int i = 0;
  93         try {
  94             for (; i < a.length; i += SPECIES.length()) {
  95                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
  96                   f.apply(a[i]));
  97             }
  98         } catch (AssertionError e) {
  99             short[] ref = f.apply(a[i]);
 100             short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 101             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 102               + ", res: " + Arrays.toString(res)
 103               + "), at index #" + i);
 104         }
 105     }
 106 
 107     static void assertArraysEquals(short[] r, short[] a, boolean[] mask, FUnOp f) {
 108         int i = 0;
 109         try {
 110             for (; i < a.length; i++) {
 111                 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
 112             }
 113         } catch (AssertionError e) {
 114             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()]);
 115         }
 116     }
 117 
 118     interface FReductionOp {
 119         short apply(short[] a, int idx);
 120     }
 121 
 122     interface FReductionAllOp {
 123         short apply(short[] a);
 124     }
 125 
 126     static void assertReductionArraysEquals(short[] r, short rc, short[] a,
 127                                             FReductionOp f, FReductionAllOp fa) {
 128         int i = 0;
 129         try {
 130             Assert.assertEquals(rc, fa.apply(a));
 131             for (; i < a.length; i += SPECIES.length()) {
 132                 Assert.assertEquals(r[i], f.apply(a, i));
 133             }
 134         } catch (AssertionError e) {
 135             Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
 136             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 137         }
 138     }
 139 
 140     interface FReductionMaskedOp {
 141         short apply(short[] a, int idx, boolean[] mask);
 142     }
 143 
 144     interface FReductionAllMaskedOp {
 145         short apply(short[] a, boolean[] mask);
 146     }
 147 
 148     static void assertReductionArraysEqualsMasked(short[] r, short rc, short[] a, boolean[] mask,
 149                                             FReductionMaskedOp f, FReductionAllMaskedOp fa) {
 150         int i = 0;
 151         try {
 152             Assert.assertEquals(rc, fa.apply(a, mask));
 153             for (; i < a.length; i += SPECIES.length()) {
 154                 Assert.assertEquals(r[i], f.apply(a, i, mask));
 155             }
 156         } catch (AssertionError e) {
 157             Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
 158             Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
 159         }
 160     }
 161 
 162     interface FReductionOpLong {
 163         long apply(short[] a, int idx);
 164     }
 165 
 166     interface FReductionAllOpLong {
 167         long apply(short[] a);
 168     }
 169 
 170     static void assertReductionLongArraysEquals(long[] r, long rc, short[] a,
 171                                             FReductionOpLong f, FReductionAllOpLong fa) {
 172         int i = 0;
 173         try {
 174             Assert.assertEquals(rc, fa.apply(a));
 175             for (; i < a.length; i += SPECIES.length()) {
 176                 Assert.assertEquals(r[i], f.apply(a, i));
 177             }
 178         } catch (AssertionError e) {
 179             Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
 180             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 181         }
 182     }
 183 
 184     interface FReductionMaskedOpLong {
 185         long apply(short[] a, int idx, boolean[] mask);
 186     }
 187 
 188     interface FReductionAllMaskedOpLong {
 189         long apply(short[] a, boolean[] mask);
 190     }
 191 
 192     static void assertReductionLongArraysEqualsMasked(long[] r, long rc, short[] a, boolean[] mask,
 193                                             FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
 194         int i = 0;
 195         try {
 196             Assert.assertEquals(rc, fa.apply(a, mask));
 197             for (; i < a.length; i += SPECIES.length()) {
 198                 Assert.assertEquals(r[i], f.apply(a, i, mask));
 199             }
 200         } catch (AssertionError e) {
 201             Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
 202             Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
 203         }
 204     }
 205 
 206     interface FBoolReductionOp {
 207         boolean apply(boolean[] a, int idx);
 208     }
 209 
 210     static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
 211         int i = 0;
 212         try {
 213             for (; i < a.length; i += SPECIES.length()) {
 214                 Assert.assertEquals(r[i], f.apply(a, i));
 215             }
 216         } catch (AssertionError e) {
 217             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 218         }
 219     }
 220 
 221     interface FMaskReductionOp {
 222         int apply(boolean[] a, int idx);
 223     }
 224 
 225     static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) {
 226         int i = 0;
 227         try {
 228             for (; i < a.length; i += SPECIES.length()) {
 229                 Assert.assertEquals(r[i], f.apply(a, i));
 230             }
 231         } catch (AssertionError e) {
 232             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 233         }
 234     }
 235 
 236     static void assertInsertArraysEquals(short[] r, short[] a, short element, int index, int start, int end) {
 237         int i = start;
 238         try {
 239             for (; i < end; i += 1) {
 240                 if(i%SPECIES.length() == index) {
 241                     Assert.assertEquals(r[i], element);
 242                 } else {
 243                     Assert.assertEquals(r[i], a[i]);
 244                 }
 245             }
 246         } catch (AssertionError e) {
 247             if (i%SPECIES.length() == index) {
 248                 Assert.assertEquals(r[i], element, "at index #" + i);
 249             } else {
 250                 Assert.assertEquals(r[i], a[i], "at index #" + i);
 251             }
 252         }
 253     }
 254 
 255     static void assertRearrangeArraysEquals(short[] r, short[] a, int[] order, int vector_len) {
 256         int i = 0, j = 0;
 257         try {
 258             for (; i < a.length; i += vector_len) {
 259                 for (j = 0; j < vector_len; j++) {
 260                     Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 261                 }
 262             }
 263         } catch (AssertionError e) {
 264             int idx = i + j;
 265             Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
 266         }
 267     }
 268 

















































 269     static void assertSelectFromArraysEquals(short[] r, short[] a, short[] order, int vector_len) {
 270         int i = 0, j = 0;
 271         try {
 272             for (; i < a.length; i += vector_len) {
 273                 for (j = 0; j < vector_len; j++) {
 274                     Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 275                 }
 276             }
 277         } catch (AssertionError e) {
 278             int idx = i + j;
 279             Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
 280         }
 281     }
 282 
 283     static void assertRearrangeArraysEquals(short[] r, short[] a, int[] order, boolean[] mask, int vector_len) {
 284         int i = 0, j = 0;
 285         try {
 286             for (; i < a.length; i += vector_len) {
 287                 for (j = 0; j < vector_len; j++) {
 288                     if (mask[j % SPECIES.length()])
 289                          Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 290                     else
 291                          Assert.assertEquals(r[i+j], (short)0);
 292                 }
 293             }
 294         } catch (AssertionError e) {
 295             int idx = i + j;
 296             if (mask[j % SPECIES.length()])
 297                 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 298             else
 299                 Assert.assertEquals(r[i+j], (short)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 300         }
 301     }
 302 
 303     static void assertSelectFromArraysEquals(short[] r, short[] a, short[] order, boolean[] mask, int vector_len) {
 304         int i = 0, j = 0;
 305         try {
 306             for (; i < a.length; i += vector_len) {
 307                 for (j = 0; j < vector_len; j++) {
 308                     if (mask[j % SPECIES.length()])
 309                          Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 310                     else
 311                          Assert.assertEquals(r[i+j], (short)0);
 312                 }
 313             }
 314         } catch (AssertionError e) {
 315             int idx = i + j;
 316             if (mask[j % SPECIES.length()])
 317                 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()]);
 318             else
 319                 Assert.assertEquals(r[i+j], (short)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 320         }
 321     }
 322 
 323     static void assertBroadcastArraysEquals(short[] r, short[] a) {
 324         int i = 0;
 325         for (; i < a.length; i += SPECIES.length()) {
 326             int idx = i;
 327             for (int j = idx; j < (idx + SPECIES.length()); j++)
 328                 a[j]=a[idx];
 329         }
 330 
 331         try {
 332             for (i = 0; i < a.length; i++) {
 333                 Assert.assertEquals(r[i], a[i]);
 334             }
 335         } catch (AssertionError e) {
 336             Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
 337         }
 338     }
 339 
 340     interface FBinOp {
 341         short apply(short a, short b);
 342     }
 343 
 344     interface FBinMaskOp {
 345         short apply(short a, short b, boolean m);
 346 
 347         static FBinMaskOp lift(FBinOp f) {
 348             return (a, b, m) -> m ? f.apply(a, b) : a;
 349         }
 350     }
 351 
 352     static void assertArraysEquals(short[] r, short[] a, short[] b, FBinOp f) {
 353         int i = 0;
 354         try {
 355             for (; i < a.length; i++) {
 356                 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
 357             }
 358         } catch (AssertionError e) {
 359             Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
 360         }
 361     }
 362 
 363     static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, FBinOp f) {
 364         int i = 0;
 365         try {
 366             for (; i < a.length; i++) {
 367                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
 368             }
 369         } catch (AssertionError e) {
 370             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
 371                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 372         }
 373     }
 374 
 375     static void assertBroadcastLongArraysEquals(short[] r, short[] a, short[] b, FBinOp f) {
 376         int i = 0;
 377         try {
 378             for (; i < a.length; i++) {
 379                 Assert.assertEquals(r[i], f.apply(a[i], (short)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
 380             }
 381         } catch (AssertionError e) {
 382             Assert.assertEquals(r[i], f.apply(a[i], (short)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
 383                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 384         }
 385     }
 386 
 387     static void assertArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
 388         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 389     }
 390 
 391     static void assertArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinMaskOp f) {
 392         int i = 0;
 393         try {
 394             for (; i < a.length; i++) {
 395                 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
 396             }
 397         } catch (AssertionError err) {
 398             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()]);
 399         }
 400     }
 401 
 402     static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
 403         assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 404     }
 405 
 406     static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinMaskOp f) {
 407         int i = 0;
 408         try {
 409             for (; i < a.length; i++) {
 410                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 411             }
 412         } catch (AssertionError err) {
 413             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 414                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 415                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 416                                 mask[i % SPECIES.length()]);
 417         }
 418     }
 419 
 420     static void assertBroadcastLongArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
 421         assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 422     }
 423 
 424     static void assertBroadcastLongArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinMaskOp f) {
 425         int i = 0;
 426         try {
 427             for (; i < a.length; i++) {
 428                 Assert.assertEquals(r[i], f.apply(a[i], (short)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
 429             }
 430         } catch (AssertionError err) {
 431             Assert.assertEquals(r[i], f.apply(a[i], (short)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
 432                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 433                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 434                                 mask[i % SPECIES.length()]);
 435         }
 436     }
 437 
 438     static void assertShiftArraysEquals(short[] r, short[] a, short[] b, FBinOp f) {
 439         int i = 0;
 440         int j = 0;
 441         try {
 442             for (; j < a.length; j += SPECIES.length()) {
 443                 for (i = 0; i < SPECIES.length(); i++) {
 444                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
 445                 }
 446             }
 447         } catch (AssertionError e) {
 448             Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
 449         }
 450     }
 451 
 452     static void assertShiftArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
 453         assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 454     }
 455 
 456     static void assertShiftArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinMaskOp f) {
 457         int i = 0;
 458         int j = 0;
 459         try {
 460             for (; j < a.length; j += SPECIES.length()) {
 461                 for (i = 0; i < SPECIES.length(); i++) {
 462                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
 463                 }
 464             }
 465         } catch (AssertionError err) {
 466             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]);
 467         }
 468     }
 469 
 470     interface FBinConstOp {
 471         short apply(short a);
 472     }
 473 
 474     interface FBinConstMaskOp {
 475         short apply(short a, boolean m);
 476 
 477         static FBinConstMaskOp lift(FBinConstOp f) {
 478             return (a, m) -> m ? f.apply(a) : a;
 479         }
 480     }
 481 
 482     static void assertShiftConstEquals(short[] r, short[] a, FBinConstOp f) {
 483         int i = 0;
 484         int j = 0;
 485         try {
 486             for (; j < a.length; j += SPECIES.length()) {
 487                 for (i = 0; i < SPECIES.length(); i++) {
 488                     Assert.assertEquals(r[i+j], f.apply(a[i+j]));
 489                 }
 490             }
 491         } catch (AssertionError e) {
 492             Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
 493         }
 494     }
 495 
 496     static void assertShiftConstEquals(short[] r, short[] a, boolean[] mask, FBinConstOp f) {
 497         assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
 498     }
 499 
 500     static void assertShiftConstEquals(short[] r, short[] a, boolean[] mask, FBinConstMaskOp f) {
 501         int i = 0;
 502         int j = 0;
 503         try {
 504             for (; j < a.length; j += SPECIES.length()) {
 505                 for (i = 0; i < SPECIES.length(); i++) {
 506                     Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
 507                 }
 508             }
 509         } catch (AssertionError err) {
 510             Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
 511         }
 512     }
 513 
 514     interface FTernOp {
 515         short apply(short a, short b, short c);
 516     }
 517 
 518     interface FTernMaskOp {
 519         short apply(short a, short b, short c, boolean m);
 520 
 521         static FTernMaskOp lift(FTernOp f) {
 522             return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
 523         }
 524     }
 525 
 526     static void assertArraysEquals(short[] r, short[] a, short[] b, short[] c, FTernOp f) {
 527         int i = 0;
 528         try {
 529             for (; i < a.length; i++) {
 530                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
 531             }
 532         } catch (AssertionError e) {
 533             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 534         }
 535     }
 536 
 537     static void assertArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask, FTernOp f) {
 538         assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 539     }
 540 
 541     static void assertArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask, FTernMaskOp f) {
 542         int i = 0;
 543         try {
 544             for (; i < a.length; i++) {
 545                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
 546             }
 547         } catch (AssertionError err) {
 548             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
 549               + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 550         }
 551     }
 552 
 553     static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, FTernOp f) {
 554         int i = 0;
 555         try {
 556             for (; i < a.length; i++) {
 557                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
 558             }
 559         } catch (AssertionError e) {
 560             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
 561                                 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
 562                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 563         }
 564     }
 565 
 566     static void assertAltBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, FTernOp f) {
 567         int i = 0;
 568         try {
 569             for (; i < a.length; i++) {
 570                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
 571             }
 572         } catch (AssertionError e) {
 573             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
 574                                 i + ", input1 = " + a[i] + ", input2 = " +
 575                                 b[(i / SPECIES.length()) * SPECIES.length()] + ",  input3 = " + c[i]);
 576         }
 577     }
 578 
 579     static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
 580                                             FTernOp f) {
 581         assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 582     }
 583 
 584     static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
 585                                             FTernMaskOp f) {
 586         int i = 0;
 587         try {
 588             for (; i < a.length; i++) {
 589                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 590                                     mask[i % SPECIES.length()]));
 591             }
 592         } catch (AssertionError err) {
 593             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 594                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
 595                                 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 596                                 mask[i % SPECIES.length()]);
 597         }
 598     }
 599 
 600     static void assertAltBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
 601                                             FTernOp f) {
 602         assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 603     }
 604 
 605     static void assertAltBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
 606                                             FTernMaskOp f) {
 607         int i = 0;
 608         try {
 609             for (; i < a.length; i++) {
 610                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 611                                     mask[i % SPECIES.length()]));
 612             }
 613         } catch (AssertionError err) {
 614             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 615                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 616                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 617                                 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 618         }
 619     }
 620 
 621     static void assertDoubleBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, FTernOp f) {
 622         int i = 0;
 623         try {
 624             for (; i < a.length; i++) {
 625                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 626                                     c[(i / SPECIES.length()) * SPECIES.length()]));
 627             }
 628         } catch (AssertionError e) {
 629             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 630                                 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
 631                                 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
 632                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 633         }
 634     }
 635 
 636     static void assertDoubleBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
 637                                                   FTernOp f) {
 638         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 639     }
 640 
 641     static void assertDoubleBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
 642                                                   FTernMaskOp f) {
 643         int i = 0;
 644         try {
 645             for (; i < a.length; i++) {
 646                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 647                                     c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 648             }
 649         } catch (AssertionError err) {
 650             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 651                                 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
 652                                 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 653                                 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 654                                 mask[i % SPECIES.length()]);
 655         }
 656     }
 657 
 658 
 659 
 660     interface FBinArrayOp {
 661         short apply(short[] a, int b);
 662     }
 663 
 664     static void assertArraysEquals(short[] r, short[] a, FBinArrayOp f) {
 665         int i = 0;
 666         try {
 667             for (; i < a.length; i++) {
 668                 Assert.assertEquals(r[i], f.apply(a, i));
 669             }
 670         } catch (AssertionError e) {
 671             Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
 672         }
 673     }
 674 
 675     interface FGatherScatterOp {
 676         short[] apply(short[] a, int ix, int[] b, int iy);
 677     }
 678 
 679     static void assertArraysEquals(short[] r, short[] a, int[] b, FGatherScatterOp f) {
 680         int i = 0;
 681         try {
 682             for (; i < a.length; i += SPECIES.length()) {
 683                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 684                   f.apply(a, i, b, i));
 685             }
 686         } catch (AssertionError e) {
 687             short[] ref = f.apply(a, i, b, i);
 688             short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 689             Assert.assertEquals(res, ref,
 690               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 691               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 692               + ", b: "
 693               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 694               + " at index #" + i);
 695         }
 696     }
 697 
 698     interface FGatherMaskedOp {
 699         short[] apply(short[] a, int ix, boolean[] mask, int[] b, int iy);
 700     }
 701 
 702     interface FScatterMaskedOp {
 703         short[] apply(short[] r, short[] a, int ix, boolean[] mask, int[] b, int iy);
 704     }
 705 
 706     static void assertArraysEquals(short[] r, short[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
 707         int i = 0;
 708         try {
 709             for (; i < a.length; i += SPECIES.length()) {
 710                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 711                   f.apply(a, i, mask, b, i));
 712             }
 713         } catch (AssertionError e) {
 714             short[] ref = f.apply(a, i, mask, b, i);
 715             short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 716             Assert.assertEquals(res, ref,
 717               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 718               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 719               + ", b: "
 720               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 721               + ", mask: "
 722               + Arrays.toString(mask)
 723               + " at index #" + i);
 724         }
 725     }
 726 
 727     static void assertArraysEquals(short[] r, short[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
 728         int i = 0;
 729         try {
 730             for (; i < a.length; i += SPECIES.length()) {
 731                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 732                   f.apply(r, a, i, mask, b, i));
 733             }
 734         } catch (AssertionError e) {
 735             short[] ref = f.apply(r, a, i, mask, b, i);
 736             short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 737             Assert.assertEquals(res, ref,
 738               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 739               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 740               + ", b: "
 741               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 742               + ", r: "
 743               + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
 744               + ", mask: "
 745               + Arrays.toString(mask)
 746               + " at index #" + i);
 747         }
 748     }
 749 
 750     interface FLaneOp {
 751         short[] apply(short[] a, int origin, int idx);
 752     }
 753 
 754     static void assertArraysEquals(short[] r, short[] a, int origin, FLaneOp f) {
 755         int i = 0;
 756         try {
 757             for (; i < a.length; i += SPECIES.length()) {
 758                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 759                   f.apply(a, origin, i));
 760             }
 761         } catch (AssertionError e) {
 762             short[] ref = f.apply(a, origin, i);
 763             short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 764             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 765               + ", res: " + Arrays.toString(res)
 766               + "), at index #" + i);
 767         }
 768     }
 769 
 770     interface FLaneBop {
 771         short[] apply(short[] a, short[] b, int origin, int idx);
 772     }
 773 
 774     static void assertArraysEquals(short[] r, short[] a, short[] b, int origin, FLaneBop f) {
 775         int i = 0;
 776         try {
 777             for (; i < a.length; i += SPECIES.length()) {
 778                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 779                   f.apply(a, b, origin, i));
 780             }
 781         } catch (AssertionError e) {
 782             short[] ref = f.apply(a, b, origin, i);
 783             short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 784             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 785               + ", res: " + Arrays.toString(res)
 786               + "), at index #" + i
 787               + ", at origin #" + origin);
 788         }
 789     }
 790 
 791     interface FLaneMaskedBop {
 792         short[] apply(short[] a, short[] b, int origin, boolean[] mask, int idx);
 793     }
 794 
 795     static void assertArraysEquals(short[] r, short[] a, short[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
 796         int i = 0;
 797         try {
 798             for (; i < a.length; i += SPECIES.length()) {
 799                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 800                   f.apply(a, b, origin, mask, i));
 801             }
 802         } catch (AssertionError e) {
 803             short[] ref = f.apply(a, b, origin, mask, i);
 804             short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 805             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 806               + ", res: " + Arrays.toString(res)
 807               + "), at index #" + i
 808               + ", at origin #" + origin);
 809         }
 810     }
 811 
 812     interface FLanePartBop {
 813         short[] apply(short[] a, short[] b, int origin, int part, int idx);
 814     }
 815 
 816     static void assertArraysEquals(short[] r, short[] a, short[] b, int origin, int part, FLanePartBop f) {
 817         int i = 0;
 818         try {
 819             for (; i < a.length; i += SPECIES.length()) {
 820                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 821                   f.apply(a, b, origin, part, i));
 822             }
 823         } catch (AssertionError e) {
 824             short[] ref = f.apply(a, b, origin, part, i);
 825             short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 826             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 827               + ", res: " + Arrays.toString(res)
 828               + "), at index #" + i
 829               + ", at origin #" + origin
 830               + ", with part #" + part);
 831         }
 832     }
 833 
 834     interface FLanePartMaskedBop {
 835         short[] apply(short[] a, short[] b, int origin, int part, boolean[] mask, int idx);
 836     }
 837 
 838     static void assertArraysEquals(short[] r, short[] a, short[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
 839         int i = 0;
 840         try {
 841             for (; i < a.length; i += SPECIES.length()) {
 842                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 843                   f.apply(a, b, origin, part, mask, i));
 844             }
 845         } catch (AssertionError e) {
 846             short[] ref = f.apply(a, b, origin, part, mask, i);
 847             short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 848             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 849               + ", res: " + Arrays.toString(res)
 850               + "), at index #" + i
 851               + ", at origin #" + origin
 852               + ", with part #" + part);
 853         }
 854     }
 855 
 856 
 857     static void assertArraysEquals(int[] r, short[] a, int offs) {
 858         int i = 0;
 859         try {
 860             for (; i < r.length; i++) {
 861                 Assert.assertEquals(r[i], (int)(a[i+offs]));
 862             }
 863         } catch (AssertionError e) {
 864             Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 865         }
 866     }
 867 
 868 
 869 
 870     static void assertArraysEquals(long[] r, short[] a, int offs) {
 871         int i = 0;
 872         try {
 873             for (; i < r.length; i++) {
 874                 Assert.assertEquals(r[i], (long)(a[i+offs]));
 875             }
 876         } catch (AssertionError e) {
 877             Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 878         }
 879     }
 880 
 881     static void assertArraysEquals(double[] r, short[] a, int offs) {
 882         int i = 0;
 883         try {
 884             for (; i < r.length; i++) {
 885                 Assert.assertEquals(r[i], (double)(a[i+offs]));
 886             }
 887         } catch (AssertionError e) {
 888             Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 889         }
 890     }
 891 
 892 
 893     static short bits(short e) {
 894         return  e;
 895     }
 896 
 897     static final List<IntFunction<short[]>> SHORT_GENERATORS = List.of(
 898             withToString("short[-i * 5]", (int s) -> {
 899                 return fill(s * BUFFER_REPS,
 900                             i -> (short)(-i * 5));
 901             }),
 902             withToString("short[i * 5]", (int s) -> {
 903                 return fill(s * BUFFER_REPS,
 904                             i -> (short)(i * 5));
 905             }),
 906             withToString("short[i + 1]", (int s) -> {
 907                 return fill(s * BUFFER_REPS,
 908                             i -> (((short)(i + 1) == 0) ? 1 : (short)(i + 1)));
 909             }),
 910             withToString("short[cornerCaseValue(i)]", (int s) -> {
 911                 return fill(s * BUFFER_REPS,
 912                             i -> cornerCaseValue(i));
 913             })
 914     );
 915 
 916     // Create combinations of pairs
 917     // @@@ Might be sensitive to order e.g. div by 0
 918     static final List<List<IntFunction<short[]>>> SHORT_GENERATOR_PAIRS =
 919         Stream.of(SHORT_GENERATORS.get(0)).
 920                 flatMap(fa -> SHORT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
 921                 collect(Collectors.toList());
 922 
 923     @DataProvider
 924     public Object[][] boolUnaryOpProvider() {
 925         return BOOL_ARRAY_GENERATORS.stream().
 926                 map(f -> new Object[]{f}).
 927                 toArray(Object[][]::new);
 928     }
 929 
 930     static final List<List<IntFunction<short[]>>> SHORT_GENERATOR_TRIPLES =
 931         SHORT_GENERATOR_PAIRS.stream().
 932                 flatMap(pair -> SHORT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
 933                 collect(Collectors.toList());
 934 
 935     @DataProvider
 936     public Object[][] shortBinaryOpProvider() {
 937         return SHORT_GENERATOR_PAIRS.stream().map(List::toArray).
 938                 toArray(Object[][]::new);
 939     }
 940 
 941     @DataProvider
 942     public Object[][] shortIndexedOpProvider() {
 943         return SHORT_GENERATOR_PAIRS.stream().map(List::toArray).
 944                 toArray(Object[][]::new);
 945     }
 946 
 947     @DataProvider
 948     public Object[][] shortBinaryOpMaskProvider() {
 949         return BOOLEAN_MASK_GENERATORS.stream().
 950                 flatMap(fm -> SHORT_GENERATOR_PAIRS.stream().map(lfa -> {
 951                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
 952                 })).
 953                 toArray(Object[][]::new);
 954     }
 955 
 956     @DataProvider
 957     public Object[][] shortTernaryOpProvider() {
 958         return SHORT_GENERATOR_TRIPLES.stream().map(List::toArray).
 959                 toArray(Object[][]::new);
 960     }
 961 
 962     @DataProvider
 963     public Object[][] shortTernaryOpMaskProvider() {
 964         return BOOLEAN_MASK_GENERATORS.stream().
 965                 flatMap(fm -> SHORT_GENERATOR_TRIPLES.stream().map(lfa -> {
 966                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
 967                 })).
 968                 toArray(Object[][]::new);
 969     }
 970 
 971     @DataProvider
 972     public Object[][] shortUnaryOpProvider() {
 973         return SHORT_GENERATORS.stream().
 974                 map(f -> new Object[]{f}).
 975                 toArray(Object[][]::new);
 976     }
 977 
 978     @DataProvider
 979     public Object[][] shortUnaryOpMaskProvider() {
 980         return BOOLEAN_MASK_GENERATORS.stream().
 981                 flatMap(fm -> SHORT_GENERATORS.stream().map(fa -> {
 982                     return new Object[] {fa, fm};
 983                 })).
 984                 toArray(Object[][]::new);
 985     }
 986 
 987 
 988 
 989     @DataProvider
 990     public Object[][] maskProvider() {
 991         return BOOLEAN_MASK_GENERATORS.stream().
 992                 map(f -> new Object[]{f}).
 993                 toArray(Object[][]::new);
 994     }
 995 
 996     @DataProvider
 997     public Object[][] maskCompareOpProvider() {
 998         return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
 999                 toArray(Object[][]::new);
1000     }
1001 
1002     @DataProvider
1003     public Object[][] shuffleProvider() {
1004         return INT_SHUFFLE_GENERATORS.stream().
1005                 map(f -> new Object[]{f}).
1006                 toArray(Object[][]::new);
1007     }
1008 
1009     @DataProvider
1010     public Object[][] shuffleCompareOpProvider() {
1011         return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1012                 toArray(Object[][]::new);
1013     }
1014 
1015     @DataProvider
1016     public Object[][] shortUnaryOpShuffleProvider() {
1017         return INT_SHUFFLE_GENERATORS.stream().
1018                 flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1019                     return new Object[] {fa, fs};
1020                 })).
1021                 toArray(Object[][]::new);
1022     }
1023 
1024     @DataProvider
1025     public Object[][] shortUnaryOpShuffleMaskProvider() {
1026         return BOOLEAN_MASK_GENERATORS.stream().
1027                 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1028                     flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1029                         return new Object[] {fa, fs, fm};
1030                 }))).
1031                 toArray(Object[][]::new);
1032     }
1033 
1034     static final List<BiFunction<Integer,Integer,short[]>> SHORT_SHUFFLE_GENERATORS = List.of(
1035             withToStringBi("shuffle[random]", (Integer l, Integer m) -> {
1036                 short[] a = new short[l];
1037                 int upper = m;
1038                 for (int i = 0; i < 1; i++) {
1039                     a[i] = (short)RAND.nextInt(upper);
1040                 }
1041                 return a;
1042             })
1043     );
1044 
1045     @DataProvider
1046     public Object[][] shortUnaryOpSelectFromProvider() {
1047         return SHORT_SHUFFLE_GENERATORS.stream().
1048                 flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1049                     return new Object[] {fa, fs};
1050                 })).
1051                 toArray(Object[][]::new);
1052     }
1053 
1054     @DataProvider
1055     public Object[][] shortUnaryOpSelectFromMaskProvider() {
1056         return BOOLEAN_MASK_GENERATORS.stream().
1057                 flatMap(fm -> SHORT_SHUFFLE_GENERATORS.stream().
1058                     flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1059                         return new Object[] {fa, fs, fm};
1060                 }))).
1061                 toArray(Object[][]::new);
1062     }
1063 
1064 
1065     static final List<IntFunction<short[]>> SHORT_COMPARE_GENERATORS = List.of(
1066             withToString("short[i]", (int s) -> {
1067                 return fill(s * BUFFER_REPS,
1068                             i -> (short)i);
1069             }),
1070             withToString("short[i - length / 2]", (int s) -> {
1071                 return fill(s * BUFFER_REPS,
1072                             i -> (short)(i - (s * BUFFER_REPS / 2)));
1073             }),
1074             withToString("short[i + 1]", (int s) -> {
1075                 return fill(s * BUFFER_REPS,
1076                             i -> (short)(i + 1));
1077             }),
1078             withToString("short[i - 2]", (int s) -> {
1079                 return fill(s * BUFFER_REPS,
1080                             i -> (short)(i - 2));
1081             }),
1082             withToString("short[zigZag(i)]", (int s) -> {
1083                 return fill(s * BUFFER_REPS,
1084                             i -> i%3 == 0 ? (short)i : (i%3 == 1 ? (short)(i + 1) : (short)(i - 2)));
1085             }),
1086             withToString("short[cornerCaseValue(i)]", (int s) -> {
1087                 return fill(s * BUFFER_REPS,
1088                             i -> cornerCaseValue(i));
1089             })
1090     );
1091 
1092     static final List<List<IntFunction<short[]>>> SHORT_TEST_GENERATOR_ARGS =
1093         SHORT_COMPARE_GENERATORS.stream().
1094                 map(fa -> List.of(fa)).
1095                 collect(Collectors.toList());
1096 
1097     @DataProvider
1098     public Object[][] shortTestOpProvider() {
1099         return SHORT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1100                 toArray(Object[][]::new);
1101     }
1102 
1103     @DataProvider
1104     public Object[][] shortTestOpMaskProvider() {
1105         return BOOLEAN_MASK_GENERATORS.stream().
1106                 flatMap(fm -> SHORT_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1107                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1108                 })).
1109                 toArray(Object[][]::new);
1110     }
1111 
1112     static final List<List<IntFunction<short[]>>> SHORT_COMPARE_GENERATOR_PAIRS =
1113         SHORT_COMPARE_GENERATORS.stream().
1114                 flatMap(fa -> SHORT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1115                 collect(Collectors.toList());
1116 
1117     @DataProvider
1118     public Object[][] shortCompareOpProvider() {
1119         return SHORT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1120                 toArray(Object[][]::new);
1121     }
1122 
1123     @DataProvider
1124     public Object[][] shortCompareOpMaskProvider() {
1125         return BOOLEAN_MASK_GENERATORS.stream().
1126                 flatMap(fm -> SHORT_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1127                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1128                 })).
1129                 toArray(Object[][]::new);
1130     }
1131 
1132     interface ToShortF {
1133         short apply(int i);
1134     }
1135 
1136     static short[] fill(int s , ToShortF f) {
1137         return fill(new short[s], f);
1138     }
1139 
1140     static short[] fill(short[] a, ToShortF f) {
1141         for (int i = 0; i < a.length; i++) {
1142             a[i] = f.apply(i);
1143         }
1144         return a;
1145     }
1146 
1147     static short cornerCaseValue(int i) {
1148         switch(i % 5) {
1149             case 0:
1150                 return Short.MAX_VALUE;
1151             case 1:
1152                 return Short.MIN_VALUE;
1153             case 2:
1154                 return Short.MIN_VALUE;
1155             case 3:
1156                 return Short.MAX_VALUE;
1157             default:
1158                 return (short)0;
1159         }
1160     }
1161 
1162     static short get(short[] a, int i) {
1163         return (short) a[i];
1164     }
1165 
1166     static final IntFunction<short[]> fr = (vl) -> {
1167         int length = BUFFER_REPS * vl;
1168         return new short[length];
1169     };
1170 
1171     static final IntFunction<boolean[]> fmr = (vl) -> {
1172         int length = BUFFER_REPS * vl;
1173         return new boolean[length];
1174     };
1175 
1176     static final IntFunction<long[]> lfr = (vl) -> {
1177         int length = BUFFER_REPS * vl;
1178         return new long[length];
1179     };
1180 
1181     static void replaceZero(short[] a, short v) {
1182         for (int i = 0; i < a.length; i++) {
1183             if (a[i] == 0) {
1184                 a[i] = v;
1185             }
1186         }
1187     }
1188 
1189     static void replaceZero(short[] a, boolean[] mask, short v) {
1190         for (int i = 0; i < a.length; i++) {
1191             if (mask[i % mask.length] && a[i] == 0) {
1192                 a[i] = v;
1193             }
1194         }
1195     }
1196 
1197     static short ROL_scalar(short a, short b) {
1198         return (short)(((((short)a) & 0xFFFF) << (b & 15)) | ((((short)a) & 0xFFFF) >>> (16 - (b & 15))));
1199     }
1200 
1201     static short ROR_scalar(short a, short b) {
1202         return (short)(((((short)a) & 0xFFFF) >>> (b & 15)) | ((((short)a) & 0xFFFF) << (16 - (b & 15))));
1203     }
1204 
















1205     static boolean eq(short a, short b) {
1206         return a == b;
1207     }
1208 
1209     static boolean neq(short a, short b) {
1210         return a != b;
1211     }
1212 
1213     static boolean lt(short a, short b) {
1214         return a < b;
1215     }
1216 
1217     static boolean le(short a, short b) {
1218         return a <= b;
1219     }
1220 
1221     static boolean gt(short a, short b) {
1222         return a > b;
1223     }
1224 
1225     static boolean ge(short a, short b) {
1226         return a >= b;
1227     }
1228 
1229     static boolean ult(short a, short b) {
1230         return Short.compareUnsigned(a, b) < 0;
1231     }
1232 
1233     static boolean ule(short a, short b) {
1234         return Short.compareUnsigned(a, b) <= 0;
1235     }
1236 
1237     static boolean ugt(short a, short b) {
1238         return Short.compareUnsigned(a, b) > 0;
1239     }
1240 
1241     static boolean uge(short a, short b) {
1242         return Short.compareUnsigned(a, b) >= 0;
1243     }
1244 
1245     static short firstNonZero(short a, short b) {
1246         return Short.compare(a, (short) 0) != 0 ? a : b;
1247     }
1248 
1249     @Test
1250     static void smokeTest1() {
1251         ShortVector three = ShortVector.broadcast(SPECIES, (byte)-3);
1252         ShortVector three2 = (ShortVector) SPECIES.broadcast(-3);
1253         assert(three.eq(three2).allTrue());
1254         ShortVector three3 = three2.broadcast(1).broadcast(-3);
1255         assert(three.eq(three3).allTrue());
1256         int scale = 2;
1257         Class<?> ETYPE = short.class;
1258         if (ETYPE == double.class || ETYPE == long.class)
1259             scale = 1000000;
1260         else if (ETYPE == byte.class && SPECIES.length() >= 64)
1261             scale = 1;
1262         ShortVector higher = three.addIndex(scale);
1263         VectorMask<Short> m = three.compare(VectorOperators.LE, higher);
1264         assert(m.allTrue());
1265         m = higher.min((short)-1).test(VectorOperators.IS_NEGATIVE);
1266         assert(m.allTrue());
1267         short max = higher.reduceLanes(VectorOperators.MAX);
1268         assert(max == -3 + scale * (SPECIES.length()-1));
1269     }
1270 
1271     private static short[]
1272     bothToArray(ShortVector a, ShortVector b) {
1273         short[] r = new short[a.length() + b.length()];
1274         a.intoArray(r, 0);
1275         b.intoArray(r, a.length());
1276         return r;
1277     }
1278 
1279     @Test
1280     static void smokeTest2() {
1281         // Do some zipping and shuffling.
1282         ShortVector io = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1283         ShortVector io2 = (ShortVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1284         Assert.assertEquals(io, io2);
1285         ShortVector a = io.add((short)1); //[1,2]
1286         ShortVector b = a.neg();  //[-1,-2]
1287         short[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1288         VectorShuffle<Short> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1289         VectorShuffle<Short> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1290         ShortVector zab0 = a.rearrange(zip0,b); //[1,-1]
1291         ShortVector zab1 = a.rearrange(zip1,b); //[2,-2]
1292         short[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1293         // manually zip
1294         short[] manual = new short[zabValues.length];
1295         for (int i = 0; i < manual.length; i += 2) {
1296             manual[i+0] = abValues[i/2];
1297             manual[i+1] = abValues[a.length() + i/2];
1298         }
1299         Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1300         VectorShuffle<Short> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1301         VectorShuffle<Short> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1302         ShortVector uab0 = zab0.rearrange(unz0,zab1);
1303         ShortVector uab1 = zab0.rearrange(unz1,zab1);
1304         short[] abValues1 = bothToArray(uab0, uab1);
1305         Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1306     }
1307 
1308     static void iotaShuffle() {
1309         ShortVector io = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1310         ShortVector io2 = (ShortVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1311         Assert.assertEquals(io, io2);
1312     }
1313 
1314     @Test
1315     // Test all shuffle related operations.
1316     static void shuffleTest() {
1317         // To test backend instructions, make sure that C2 is used.
1318         for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1319             iotaShuffle();
1320         }
1321     }
1322 
1323     @Test
1324     void viewAsIntegeralLanesTest() {
1325         Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1326         Assert.assertEquals(asIntegral.species(), SPECIES);
1327     }
1328 
1329     @Test(expectedExceptions = UnsupportedOperationException.class)
1330     void viewAsFloatingLanesTest() {
1331         SPECIES.zero().viewAsFloatingLanes();
1332     }
1333 
1334     @Test
1335     // Test div by 0.
1336     static void bitwiseDivByZeroSmokeTest() {
1337         try {
1338             ShortVector a = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1339             ShortVector b = (ShortVector) SPECIES.broadcast(0);
1340             a.div(b);
1341             Assert.fail();
1342         } catch (ArithmeticException e) {
1343         }
1344 
1345         try {
1346             ShortVector a = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1347             ShortVector b = (ShortVector) SPECIES.broadcast(0);
1348             VectorMask<Short> m = a.lt((short) 1);
1349             a.div(b, m);
1350             Assert.fail();
1351         } catch (ArithmeticException e) {
1352         }
1353     }

1354     static short ADD(short a, short b) {
1355         return (short)(a + b);
1356     }
1357 
1358     @Test(dataProvider = "shortBinaryOpProvider")
1359     static void ADDShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1360         short[] a = fa.apply(SPECIES.length());
1361         short[] b = fb.apply(SPECIES.length());
1362         short[] r = fr.apply(SPECIES.length());
1363 
1364         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1365             for (int i = 0; i < a.length; i += SPECIES.length()) {
1366                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1367                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1368                 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1369             }
1370         }
1371 
1372         assertArraysEquals(r, a, b, ShortMaxVectorTests::ADD);
1373     }

1374     static short add(short a, short b) {
1375         return (short)(a + b);
1376     }
1377 
1378     @Test(dataProvider = "shortBinaryOpProvider")
1379     static void addShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1380         short[] a = fa.apply(SPECIES.length());
1381         short[] b = fb.apply(SPECIES.length());
1382         short[] r = fr.apply(SPECIES.length());
1383 
1384         for (int i = 0; i < a.length; i += SPECIES.length()) {
1385             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1386             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1387             av.add(bv).intoArray(r, i);
1388         }
1389 
1390         assertArraysEquals(r, a, b, ShortMaxVectorTests::add);
1391     }
1392 
1393     @Test(dataProvider = "shortBinaryOpMaskProvider")
1394     static void ADDShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1395                                           IntFunction<boolean[]> fm) {
1396         short[] a = fa.apply(SPECIES.length());
1397         short[] b = fb.apply(SPECIES.length());
1398         short[] r = fr.apply(SPECIES.length());
1399         boolean[] mask = fm.apply(SPECIES.length());
1400         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1401 
1402         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1403             for (int i = 0; i < a.length; i += SPECIES.length()) {
1404                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1405                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1406                 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1407             }
1408         }
1409 
1410         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ADD);
1411     }
1412 
1413     @Test(dataProvider = "shortBinaryOpMaskProvider")
1414     static void addShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1415                                           IntFunction<boolean[]> fm) {
1416         short[] a = fa.apply(SPECIES.length());
1417         short[] b = fb.apply(SPECIES.length());
1418         short[] r = fr.apply(SPECIES.length());
1419         boolean[] mask = fm.apply(SPECIES.length());
1420         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1421 
1422         for (int i = 0; i < a.length; i += SPECIES.length()) {
1423             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1424             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1425             av.add(bv, vmask).intoArray(r, i);
1426         }
1427 
1428         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::add);
1429     }

1430     static short SUB(short a, short b) {
1431         return (short)(a - b);
1432     }
1433 
1434     @Test(dataProvider = "shortBinaryOpProvider")
1435     static void SUBShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1436         short[] a = fa.apply(SPECIES.length());
1437         short[] b = fb.apply(SPECIES.length());
1438         short[] r = fr.apply(SPECIES.length());
1439 
1440         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1441             for (int i = 0; i < a.length; i += SPECIES.length()) {
1442                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1443                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1444                 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1445             }
1446         }
1447 
1448         assertArraysEquals(r, a, b, ShortMaxVectorTests::SUB);
1449     }

1450     static short sub(short a, short b) {
1451         return (short)(a - b);
1452     }
1453 
1454     @Test(dataProvider = "shortBinaryOpProvider")
1455     static void subShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1456         short[] a = fa.apply(SPECIES.length());
1457         short[] b = fb.apply(SPECIES.length());
1458         short[] r = fr.apply(SPECIES.length());
1459 
1460         for (int i = 0; i < a.length; i += SPECIES.length()) {
1461             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1462             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1463             av.sub(bv).intoArray(r, i);
1464         }
1465 
1466         assertArraysEquals(r, a, b, ShortMaxVectorTests::sub);
1467     }
1468 
1469     @Test(dataProvider = "shortBinaryOpMaskProvider")
1470     static void SUBShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1471                                           IntFunction<boolean[]> fm) {
1472         short[] a = fa.apply(SPECIES.length());
1473         short[] b = fb.apply(SPECIES.length());
1474         short[] r = fr.apply(SPECIES.length());
1475         boolean[] mask = fm.apply(SPECIES.length());
1476         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1477 
1478         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1479             for (int i = 0; i < a.length; i += SPECIES.length()) {
1480                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1481                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1482                 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1483             }
1484         }
1485 
1486         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::SUB);
1487     }
1488 
1489     @Test(dataProvider = "shortBinaryOpMaskProvider")
1490     static void subShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1491                                           IntFunction<boolean[]> fm) {
1492         short[] a = fa.apply(SPECIES.length());
1493         short[] b = fb.apply(SPECIES.length());
1494         short[] r = fr.apply(SPECIES.length());
1495         boolean[] mask = fm.apply(SPECIES.length());
1496         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1497 
1498         for (int i = 0; i < a.length; i += SPECIES.length()) {
1499             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1500             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1501             av.sub(bv, vmask).intoArray(r, i);
1502         }
1503 
1504         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::sub);
1505     }

1506     static short MUL(short a, short b) {
1507         return (short)(a * b);
1508     }
1509 
1510     @Test(dataProvider = "shortBinaryOpProvider")
1511     static void MULShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1512         short[] a = fa.apply(SPECIES.length());
1513         short[] b = fb.apply(SPECIES.length());
1514         short[] r = fr.apply(SPECIES.length());
1515 
1516         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1517             for (int i = 0; i < a.length; i += SPECIES.length()) {
1518                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1519                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1520                 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1521             }
1522         }
1523 
1524         assertArraysEquals(r, a, b, ShortMaxVectorTests::MUL);
1525     }

1526     static short mul(short a, short b) {
1527         return (short)(a * b);
1528     }
1529 
1530     @Test(dataProvider = "shortBinaryOpProvider")
1531     static void mulShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1532         short[] a = fa.apply(SPECIES.length());
1533         short[] b = fb.apply(SPECIES.length());
1534         short[] r = fr.apply(SPECIES.length());
1535 
1536         for (int i = 0; i < a.length; i += SPECIES.length()) {
1537             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1538             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1539             av.mul(bv).intoArray(r, i);
1540         }
1541 
1542         assertArraysEquals(r, a, b, ShortMaxVectorTests::mul);
1543     }
1544 
1545     @Test(dataProvider = "shortBinaryOpMaskProvider")
1546     static void MULShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1547                                           IntFunction<boolean[]> fm) {
1548         short[] a = fa.apply(SPECIES.length());
1549         short[] b = fb.apply(SPECIES.length());
1550         short[] r = fr.apply(SPECIES.length());
1551         boolean[] mask = fm.apply(SPECIES.length());
1552         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1553 
1554         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1555             for (int i = 0; i < a.length; i += SPECIES.length()) {
1556                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1557                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1558                 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1559             }
1560         }
1561 
1562         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::MUL);
1563     }
1564 
1565     @Test(dataProvider = "shortBinaryOpMaskProvider")
1566     static void mulShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1567                                           IntFunction<boolean[]> fm) {
1568         short[] a = fa.apply(SPECIES.length());
1569         short[] b = fb.apply(SPECIES.length());
1570         short[] r = fr.apply(SPECIES.length());
1571         boolean[] mask = fm.apply(SPECIES.length());
1572         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1573 
1574         for (int i = 0; i < a.length; i += SPECIES.length()) {
1575             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1576             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1577             av.mul(bv, vmask).intoArray(r, i);
1578         }
1579 
1580         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::mul);
1581     }
1582 
1583 
1584 
1585     static short DIV(short a, short b) {
1586         return (short)(a / b);
1587     }
1588 
1589     @Test(dataProvider = "shortBinaryOpProvider")
1590     static void DIVShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1591         short[] a = fa.apply(SPECIES.length());
1592         short[] b = fb.apply(SPECIES.length());
1593         short[] r = fr.apply(SPECIES.length());
1594 
1595         replaceZero(b, (short) 1);
1596 
1597         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1598             for (int i = 0; i < a.length; i += SPECIES.length()) {
1599                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1600                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1601                 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1602             }
1603         }
1604 
1605         assertArraysEquals(r, a, b, ShortMaxVectorTests::DIV);
1606     }

1607     static short div(short a, short b) {
1608         return (short)(a / b);
1609     }
1610 
1611     @Test(dataProvider = "shortBinaryOpProvider")
1612     static void divShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1613         short[] a = fa.apply(SPECIES.length());
1614         short[] b = fb.apply(SPECIES.length());
1615         short[] r = fr.apply(SPECIES.length());
1616 
1617         replaceZero(b, (short) 1);
1618 
1619         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1620             for (int i = 0; i < a.length; i += SPECIES.length()) {
1621                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1622                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1623                 av.div(bv).intoArray(r, i);
1624             }
1625         }
1626 
1627         assertArraysEquals(r, a, b, ShortMaxVectorTests::div);
1628     }
1629 
1630 
1631 
1632     @Test(dataProvider = "shortBinaryOpMaskProvider")
1633     static void DIVShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1634                                           IntFunction<boolean[]> fm) {
1635         short[] a = fa.apply(SPECIES.length());
1636         short[] b = fb.apply(SPECIES.length());
1637         short[] r = fr.apply(SPECIES.length());
1638         boolean[] mask = fm.apply(SPECIES.length());
1639         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1640 
1641         replaceZero(b, mask, (short) 1);
1642 
1643         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1644             for (int i = 0; i < a.length; i += SPECIES.length()) {
1645                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1646                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1647                 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1648             }
1649         }
1650 
1651         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::DIV);
1652     }
1653 
1654     @Test(dataProvider = "shortBinaryOpMaskProvider")
1655     static void divShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1656                                           IntFunction<boolean[]> fm) {
1657         short[] a = fa.apply(SPECIES.length());
1658         short[] b = fb.apply(SPECIES.length());
1659         short[] r = fr.apply(SPECIES.length());
1660         boolean[] mask = fm.apply(SPECIES.length());
1661         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1662 
1663         replaceZero(b, mask, (short) 1);
1664 
1665         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1666             for (int i = 0; i < a.length; i += SPECIES.length()) {
1667                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1668                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1669                 av.div(bv, vmask).intoArray(r, i);
1670             }
1671         }
1672 
1673         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::div);
1674     }
1675 
1676     static short FIRST_NONZERO(short a, short b) {
1677         return (short)((a)!=0?a:b);
1678     }
1679 
1680     @Test(dataProvider = "shortBinaryOpProvider")
1681     static void FIRST_NONZEROShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1682         short[] a = fa.apply(SPECIES.length());
1683         short[] b = fb.apply(SPECIES.length());
1684         short[] r = fr.apply(SPECIES.length());
1685 
1686         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1687             for (int i = 0; i < a.length; i += SPECIES.length()) {
1688                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1689                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1690                 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1691             }
1692         }
1693 
1694         assertArraysEquals(r, a, b, ShortMaxVectorTests::FIRST_NONZERO);
1695     }
1696 
1697     @Test(dataProvider = "shortBinaryOpMaskProvider")
1698     static void FIRST_NONZEROShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1699                                           IntFunction<boolean[]> fm) {
1700         short[] a = fa.apply(SPECIES.length());
1701         short[] b = fb.apply(SPECIES.length());
1702         short[] r = fr.apply(SPECIES.length());
1703         boolean[] mask = fm.apply(SPECIES.length());
1704         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1705 
1706         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1707             for (int i = 0; i < a.length; i += SPECIES.length()) {
1708                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1709                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1710                 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1711             }
1712         }
1713 
1714         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::FIRST_NONZERO);
1715     }
1716 
1717     static short AND(short a, short b) {
1718         return (short)(a & b);
1719     }
1720 
1721     @Test(dataProvider = "shortBinaryOpProvider")
1722     static void ANDShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1723         short[] a = fa.apply(SPECIES.length());
1724         short[] b = fb.apply(SPECIES.length());
1725         short[] r = fr.apply(SPECIES.length());
1726 
1727         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1728             for (int i = 0; i < a.length; i += SPECIES.length()) {
1729                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1730                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1731                 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1732             }
1733         }
1734 
1735         assertArraysEquals(r, a, b, ShortMaxVectorTests::AND);
1736     }

1737     static short and(short a, short b) {
1738         return (short)(a & b);
1739     }
1740 
1741     @Test(dataProvider = "shortBinaryOpProvider")
1742     static void andShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1743         short[] a = fa.apply(SPECIES.length());
1744         short[] b = fb.apply(SPECIES.length());
1745         short[] r = fr.apply(SPECIES.length());
1746 
1747         for (int i = 0; i < a.length; i += SPECIES.length()) {
1748             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1749             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1750             av.and(bv).intoArray(r, i);
1751         }
1752 
1753         assertArraysEquals(r, a, b, ShortMaxVectorTests::and);
1754     }
1755 
1756 
1757 
1758     @Test(dataProvider = "shortBinaryOpMaskProvider")
1759     static void ANDShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1760                                           IntFunction<boolean[]> fm) {
1761         short[] a = fa.apply(SPECIES.length());
1762         short[] b = fb.apply(SPECIES.length());
1763         short[] r = fr.apply(SPECIES.length());
1764         boolean[] mask = fm.apply(SPECIES.length());
1765         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1766 
1767         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1768             for (int i = 0; i < a.length; i += SPECIES.length()) {
1769                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1770                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1771                 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1772             }
1773         }
1774 
1775         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::AND);
1776     }
1777 
1778 
1779     static short AND_NOT(short a, short b) {
1780         return (short)(a & ~b);
1781     }
1782 
1783     @Test(dataProvider = "shortBinaryOpProvider")
1784     static void AND_NOTShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1785         short[] a = fa.apply(SPECIES.length());
1786         short[] b = fb.apply(SPECIES.length());
1787         short[] r = fr.apply(SPECIES.length());
1788 
1789         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1790             for (int i = 0; i < a.length; i += SPECIES.length()) {
1791                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1792                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1793                 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
1794             }
1795         }
1796 
1797         assertArraysEquals(r, a, b, ShortMaxVectorTests::AND_NOT);
1798     }
1799 
1800 
1801 
1802     @Test(dataProvider = "shortBinaryOpMaskProvider")
1803     static void AND_NOTShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1804                                           IntFunction<boolean[]> fm) {
1805         short[] a = fa.apply(SPECIES.length());
1806         short[] b = fb.apply(SPECIES.length());
1807         short[] r = fr.apply(SPECIES.length());
1808         boolean[] mask = fm.apply(SPECIES.length());
1809         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1810 
1811         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1812             for (int i = 0; i < a.length; i += SPECIES.length()) {
1813                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1814                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1815                 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
1816             }
1817         }
1818 
1819         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::AND_NOT);
1820     }
1821 
1822 
1823     static short OR(short a, short b) {
1824         return (short)(a | b);
1825     }
1826 
1827     @Test(dataProvider = "shortBinaryOpProvider")
1828     static void ORShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1829         short[] a = fa.apply(SPECIES.length());
1830         short[] b = fb.apply(SPECIES.length());
1831         short[] r = fr.apply(SPECIES.length());
1832 
1833         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1834             for (int i = 0; i < a.length; i += SPECIES.length()) {
1835                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1836                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1837                 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1838             }
1839         }
1840 
1841         assertArraysEquals(r, a, b, ShortMaxVectorTests::OR);
1842     }

1843     static short or(short a, short b) {
1844         return (short)(a | b);
1845     }
1846 
1847     @Test(dataProvider = "shortBinaryOpProvider")
1848     static void orShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1849         short[] a = fa.apply(SPECIES.length());
1850         short[] b = fb.apply(SPECIES.length());
1851         short[] r = fr.apply(SPECIES.length());
1852 
1853         for (int i = 0; i < a.length; i += SPECIES.length()) {
1854             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1855             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1856             av.or(bv).intoArray(r, i);
1857         }
1858 
1859         assertArraysEquals(r, a, b, ShortMaxVectorTests::or);
1860     }
1861 
1862 
1863 
1864     @Test(dataProvider = "shortBinaryOpMaskProvider")
1865     static void ORShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1866                                           IntFunction<boolean[]> fm) {
1867         short[] a = fa.apply(SPECIES.length());
1868         short[] b = fb.apply(SPECIES.length());
1869         short[] r = fr.apply(SPECIES.length());
1870         boolean[] mask = fm.apply(SPECIES.length());
1871         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1872 
1873         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1874             for (int i = 0; i < a.length; i += SPECIES.length()) {
1875                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1876                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1877                 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1878             }
1879         }
1880 
1881         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::OR);
1882     }
1883 
1884 
1885     static short XOR(short a, short b) {
1886         return (short)(a ^ b);
1887     }
1888 
1889     @Test(dataProvider = "shortBinaryOpProvider")
1890     static void XORShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1891         short[] a = fa.apply(SPECIES.length());
1892         short[] b = fb.apply(SPECIES.length());
1893         short[] r = fr.apply(SPECIES.length());
1894 
1895         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1896             for (int i = 0; i < a.length; i += SPECIES.length()) {
1897                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1898                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1899                 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
1900             }
1901         }
1902 
1903         assertArraysEquals(r, a, b, ShortMaxVectorTests::XOR);
1904     }
1905 
1906 
1907 
1908     @Test(dataProvider = "shortBinaryOpMaskProvider")
1909     static void XORShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1910                                           IntFunction<boolean[]> fm) {
1911         short[] a = fa.apply(SPECIES.length());
1912         short[] b = fb.apply(SPECIES.length());
1913         short[] r = fr.apply(SPECIES.length());
1914         boolean[] mask = fm.apply(SPECIES.length());
1915         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1916 
1917         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1918             for (int i = 0; i < a.length; i += SPECIES.length()) {
1919                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1920                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1921                 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1922             }
1923         }
1924 
1925         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::XOR);
1926     }
1927 
1928 
1929     @Test(dataProvider = "shortBinaryOpProvider")
1930     static void addShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1931         short[] a = fa.apply(SPECIES.length());
1932         short[] b = fb.apply(SPECIES.length());
1933         short[] r = fr.apply(SPECIES.length());
1934 
1935         for (int i = 0; i < a.length; i += SPECIES.length()) {
1936             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1937             av.add(b[i]).intoArray(r, i);
1938         }
1939 
1940         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::add);
1941     }
1942 
1943     @Test(dataProvider = "shortBinaryOpMaskProvider")
1944     static void addShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
1945                                           IntFunction<boolean[]> fm) {
1946         short[] a = fa.apply(SPECIES.length());
1947         short[] b = fb.apply(SPECIES.length());
1948         short[] r = fr.apply(SPECIES.length());
1949         boolean[] mask = fm.apply(SPECIES.length());
1950         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1951 
1952         for (int i = 0; i < a.length; i += SPECIES.length()) {
1953             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1954             av.add(b[i], vmask).intoArray(r, i);
1955         }
1956 
1957         assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::add);
1958     }
1959 
1960     @Test(dataProvider = "shortBinaryOpProvider")
1961     static void subShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1962         short[] a = fa.apply(SPECIES.length());
1963         short[] b = fb.apply(SPECIES.length());
1964         short[] r = fr.apply(SPECIES.length());
1965 
1966         for (int i = 0; i < a.length; i += SPECIES.length()) {
1967             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1968             av.sub(b[i]).intoArray(r, i);
1969         }
1970 
1971         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::sub);
1972     }
1973 
1974     @Test(dataProvider = "shortBinaryOpMaskProvider")
1975     static void subShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
1976                                           IntFunction<boolean[]> fm) {
1977         short[] a = fa.apply(SPECIES.length());
1978         short[] b = fb.apply(SPECIES.length());
1979         short[] r = fr.apply(SPECIES.length());
1980         boolean[] mask = fm.apply(SPECIES.length());
1981         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1982 
1983         for (int i = 0; i < a.length; i += SPECIES.length()) {
1984             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1985             av.sub(b[i], vmask).intoArray(r, i);
1986         }
1987 
1988         assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::sub);
1989     }
1990 
1991     @Test(dataProvider = "shortBinaryOpProvider")
1992     static void mulShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1993         short[] a = fa.apply(SPECIES.length());
1994         short[] b = fb.apply(SPECIES.length());
1995         short[] r = fr.apply(SPECIES.length());
1996 
1997         for (int i = 0; i < a.length; i += SPECIES.length()) {
1998             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1999             av.mul(b[i]).intoArray(r, i);
2000         }
2001 
2002         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::mul);
2003     }
2004 
2005     @Test(dataProvider = "shortBinaryOpMaskProvider")
2006     static void mulShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2007                                           IntFunction<boolean[]> fm) {
2008         short[] a = fa.apply(SPECIES.length());
2009         short[] b = fb.apply(SPECIES.length());
2010         short[] r = fr.apply(SPECIES.length());
2011         boolean[] mask = fm.apply(SPECIES.length());
2012         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2013 
2014         for (int i = 0; i < a.length; i += SPECIES.length()) {
2015             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2016             av.mul(b[i], vmask).intoArray(r, i);
2017         }
2018 
2019         assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::mul);
2020     }
2021 
2022 
2023 
2024 
2025     @Test(dataProvider = "shortBinaryOpProvider")
2026     static void divShortMaxVectorTestsBroadcastSmokeTest(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         replaceZero(b, (short) 1);
2032 
2033         for (int i = 0; i < a.length; i += SPECIES.length()) {
2034             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2035             av.div(b[i]).intoArray(r, i);
2036         }
2037 
2038         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::div);
2039     }
2040 
2041 
2042 
2043     @Test(dataProvider = "shortBinaryOpMaskProvider")
2044     static void divShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2045                                           IntFunction<boolean[]> fm) {
2046         short[] a = fa.apply(SPECIES.length());
2047         short[] b = fb.apply(SPECIES.length());
2048         short[] r = fr.apply(SPECIES.length());
2049         boolean[] mask = fm.apply(SPECIES.length());
2050         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2051 
2052         replaceZero(b, (short) 1);
2053 
2054         for (int i = 0; i < a.length; i += SPECIES.length()) {
2055             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2056             av.div(b[i], vmask).intoArray(r, i);
2057         }
2058 
2059         assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::div);
2060     }
2061 
2062 
2063 
2064     @Test(dataProvider = "shortBinaryOpProvider")
2065     static void ORShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2066         short[] a = fa.apply(SPECIES.length());
2067         short[] b = fb.apply(SPECIES.length());
2068         short[] r = fr.apply(SPECIES.length());
2069 
2070         for (int i = 0; i < a.length; i += SPECIES.length()) {
2071             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2072             av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
2073         }
2074 
2075         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::OR);
2076     }
2077 
2078     @Test(dataProvider = "shortBinaryOpProvider")
2079     static void orShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2080         short[] a = fa.apply(SPECIES.length());
2081         short[] b = fb.apply(SPECIES.length());
2082         short[] r = fr.apply(SPECIES.length());
2083 
2084         for (int i = 0; i < a.length; i += SPECIES.length()) {
2085             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2086             av.or(b[i]).intoArray(r, i);
2087         }
2088 
2089         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::or);
2090     }
2091 
2092 
2093 
2094     @Test(dataProvider = "shortBinaryOpMaskProvider")
2095     static void ORShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2096                                           IntFunction<boolean[]> fm) {
2097         short[] a = fa.apply(SPECIES.length());
2098         short[] b = fb.apply(SPECIES.length());
2099         short[] r = fr.apply(SPECIES.length());
2100         boolean[] mask = fm.apply(SPECIES.length());
2101         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2102 
2103         for (int i = 0; i < a.length; i += SPECIES.length()) {
2104             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2105             av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
2106         }
2107 
2108         assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::OR);
2109     }
2110 
2111 
2112 
2113     @Test(dataProvider = "shortBinaryOpProvider")
2114     static void ANDShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2115         short[] a = fa.apply(SPECIES.length());
2116         short[] b = fb.apply(SPECIES.length());
2117         short[] r = fr.apply(SPECIES.length());
2118 
2119         for (int i = 0; i < a.length; i += SPECIES.length()) {
2120             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2121             av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
2122         }
2123 
2124         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::AND);
2125     }
2126 
2127     @Test(dataProvider = "shortBinaryOpProvider")
2128     static void andShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2129         short[] a = fa.apply(SPECIES.length());
2130         short[] b = fb.apply(SPECIES.length());
2131         short[] r = fr.apply(SPECIES.length());
2132 
2133         for (int i = 0; i < a.length; i += SPECIES.length()) {
2134             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2135             av.and(b[i]).intoArray(r, i);
2136         }
2137 
2138         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::and);
2139     }
2140 
2141 
2142 
2143     @Test(dataProvider = "shortBinaryOpMaskProvider")
2144     static void ANDShortMaxVectorTestsBroadcastMaskedSmokeTest(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 i = 0; i < a.length; i += SPECIES.length()) {
2153             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2154             av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
2155         }
2156 
2157         assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::AND);
2158     }
2159 
2160 
2161 
2162     @Test(dataProvider = "shortBinaryOpProvider")
2163     static void ORShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2164         short[] a = fa.apply(SPECIES.length());
2165         short[] b = fb.apply(SPECIES.length());
2166         short[] r = fr.apply(SPECIES.length());
2167 
2168         for (int i = 0; i < a.length; i += SPECIES.length()) {
2169             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2170             av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
2171         }
2172 
2173         assertBroadcastLongArraysEquals(r, a, b, ShortMaxVectorTests::OR);
2174     }
2175 
2176 
2177 
2178     @Test(dataProvider = "shortBinaryOpMaskProvider")
2179     static void ORShortMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2180                                           IntFunction<boolean[]> fm) {
2181         short[] a = fa.apply(SPECIES.length());
2182         short[] b = fb.apply(SPECIES.length());
2183         short[] r = fr.apply(SPECIES.length());
2184         boolean[] mask = fm.apply(SPECIES.length());
2185         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2186 
2187         for (int i = 0; i < a.length; i += SPECIES.length()) {
2188             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2189             av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
2190         }
2191 
2192         assertBroadcastLongArraysEquals(r, a, b, mask, ShortMaxVectorTests::OR);
2193     }
2194 
2195 
2196     @Test(dataProvider = "shortBinaryOpProvider")
2197     static void ADDShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2198         short[] a = fa.apply(SPECIES.length());
2199         short[] b = fb.apply(SPECIES.length());
2200         short[] r = fr.apply(SPECIES.length());
2201 
2202         for (int i = 0; i < a.length; i += SPECIES.length()) {
2203             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2204             av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2205         }
2206 
2207         assertBroadcastLongArraysEquals(r, a, b, ShortMaxVectorTests::ADD);
2208     }
2209 
2210     @Test(dataProvider = "shortBinaryOpMaskProvider")
2211     static void ADDShortMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2212                                           IntFunction<boolean[]> fm) {
2213         short[] a = fa.apply(SPECIES.length());
2214         short[] b = fb.apply(SPECIES.length());
2215         short[] r = fr.apply(SPECIES.length());
2216         boolean[] mask = fm.apply(SPECIES.length());
2217         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2218 
2219         for (int i = 0; i < a.length; i += SPECIES.length()) {
2220             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2221             av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2222         }
2223 
2224         assertBroadcastLongArraysEquals(r, a, b, mask, ShortMaxVectorTests::ADD);
2225     }
2226 
2227 
2228 
2229 
2230 
2231     static short LSHL(short a, short b) {
2232         return (short)((a << (b & 0xF)));
2233     }
2234 
2235     @Test(dataProvider = "shortBinaryOpProvider")
2236     static void LSHLShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2237         short[] a = fa.apply(SPECIES.length());
2238         short[] b = fb.apply(SPECIES.length());
2239         short[] r = fr.apply(SPECIES.length());
2240 
2241         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2242             for (int i = 0; i < a.length; i += SPECIES.length()) {
2243                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2244                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2245                 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
2246             }
2247         }
2248 
2249         assertArraysEquals(r, a, b, ShortMaxVectorTests::LSHL);
2250     }
2251 
2252 
2253 
2254     @Test(dataProvider = "shortBinaryOpMaskProvider")
2255     static void LSHLShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2256                                           IntFunction<boolean[]> fm) {
2257         short[] a = fa.apply(SPECIES.length());
2258         short[] b = fb.apply(SPECIES.length());
2259         short[] r = fr.apply(SPECIES.length());
2260         boolean[] mask = fm.apply(SPECIES.length());
2261         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2262 
2263         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2264             for (int i = 0; i < a.length; i += SPECIES.length()) {
2265                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2266                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2267                 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
2268             }
2269         }
2270 
2271         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHL);
2272     }
2273 
2274 
2275 
2276 
2277 
2278 
2279     static short ASHR(short a, short b) {
2280         return (short)((a >> (b & 0xF)));
2281     }
2282 
2283     @Test(dataProvider = "shortBinaryOpProvider")
2284     static void ASHRShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2285         short[] a = fa.apply(SPECIES.length());
2286         short[] b = fb.apply(SPECIES.length());
2287         short[] r = fr.apply(SPECIES.length());
2288 
2289         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2290             for (int i = 0; i < a.length; i += SPECIES.length()) {
2291                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2292                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2293                 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
2294             }
2295         }
2296 
2297         assertArraysEquals(r, a, b, ShortMaxVectorTests::ASHR);
2298     }
2299 
2300 
2301 
2302     @Test(dataProvider = "shortBinaryOpMaskProvider")
2303     static void ASHRShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2304                                           IntFunction<boolean[]> fm) {
2305         short[] a = fa.apply(SPECIES.length());
2306         short[] b = fb.apply(SPECIES.length());
2307         short[] r = fr.apply(SPECIES.length());
2308         boolean[] mask = fm.apply(SPECIES.length());
2309         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2310 
2311         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2312             for (int i = 0; i < a.length; i += SPECIES.length()) {
2313                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2314                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2315                 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
2316             }
2317         }
2318 
2319         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ASHR);
2320     }
2321 
2322 
2323 
2324 
2325 
2326 
2327     static short LSHR(short a, short b) {
2328         return (short)(((a & 0xFFFF) >>> (b & 0xF)));
2329     }
2330 
2331     @Test(dataProvider = "shortBinaryOpProvider")
2332     static void LSHRShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2333         short[] a = fa.apply(SPECIES.length());
2334         short[] b = fb.apply(SPECIES.length());
2335         short[] r = fr.apply(SPECIES.length());
2336 
2337         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2338             for (int i = 0; i < a.length; i += SPECIES.length()) {
2339                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2340                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2341                 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
2342             }
2343         }
2344 
2345         assertArraysEquals(r, a, b, ShortMaxVectorTests::LSHR);
2346     }
2347 
2348 
2349 
2350     @Test(dataProvider = "shortBinaryOpMaskProvider")
2351     static void LSHRShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2352                                           IntFunction<boolean[]> fm) {
2353         short[] a = fa.apply(SPECIES.length());
2354         short[] b = fb.apply(SPECIES.length());
2355         short[] r = fr.apply(SPECIES.length());
2356         boolean[] mask = fm.apply(SPECIES.length());
2357         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2358 
2359         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2360             for (int i = 0; i < a.length; i += SPECIES.length()) {
2361                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2362                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2363                 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
2364             }
2365         }
2366 
2367         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHR);
2368     }
2369 
2370 
2371 
2372 
2373 
2374 
2375     static short LSHL_unary(short a, short b) {
2376         return (short)((a << (b & 15)));
2377     }
2378 
2379     @Test(dataProvider = "shortBinaryOpProvider")
2380     static void LSHLShortMaxVectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2381         short[] a = fa.apply(SPECIES.length());
2382         short[] b = fb.apply(SPECIES.length());
2383         short[] r = fr.apply(SPECIES.length());
2384 
2385         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2386             for (int i = 0; i < a.length; i += SPECIES.length()) {
2387                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2388                 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
2389             }
2390         }
2391 
2392         assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::LSHL_unary);
2393     }
2394 
2395 
2396 
2397     @Test(dataProvider = "shortBinaryOpMaskProvider")
2398     static void LSHLShortMaxVectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2399                                           IntFunction<boolean[]> fm) {
2400         short[] a = fa.apply(SPECIES.length());
2401         short[] b = fb.apply(SPECIES.length());
2402         short[] r = fr.apply(SPECIES.length());
2403         boolean[] mask = fm.apply(SPECIES.length());
2404         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2405 
2406         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2407             for (int i = 0; i < a.length; i += SPECIES.length()) {
2408                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2409                 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
2410             }
2411         }
2412 
2413         assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHL_unary);
2414     }
2415 
2416 
2417 
2418 
2419 
2420 
2421     static short LSHR_unary(short a, short b) {
2422         return (short)(((a & 0xFFFF) >>> (b & 15)));
2423     }
2424 
2425     @Test(dataProvider = "shortBinaryOpProvider")
2426     static void LSHRShortMaxVectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2427         short[] a = fa.apply(SPECIES.length());
2428         short[] b = fb.apply(SPECIES.length());
2429         short[] r = fr.apply(SPECIES.length());
2430 
2431         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2432             for (int i = 0; i < a.length; i += SPECIES.length()) {
2433                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2434                 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
2435             }
2436         }
2437 
2438         assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::LSHR_unary);
2439     }
2440 
2441 
2442 
2443     @Test(dataProvider = "shortBinaryOpMaskProvider")
2444     static void LSHRShortMaxVectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2445                                           IntFunction<boolean[]> fm) {
2446         short[] a = fa.apply(SPECIES.length());
2447         short[] b = fb.apply(SPECIES.length());
2448         short[] r = fr.apply(SPECIES.length());
2449         boolean[] mask = fm.apply(SPECIES.length());
2450         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2451 
2452         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2453             for (int i = 0; i < a.length; i += SPECIES.length()) {
2454                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2455                 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
2456             }
2457         }
2458 
2459         assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHR_unary);
2460     }
2461 
2462 
2463 
2464 
2465 
2466 
2467     static short ASHR_unary(short a, short b) {
2468         return (short)((a >> (b & 15)));
2469     }
2470 
2471     @Test(dataProvider = "shortBinaryOpProvider")
2472     static void ASHRShortMaxVectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2473         short[] a = fa.apply(SPECIES.length());
2474         short[] b = fb.apply(SPECIES.length());
2475         short[] r = fr.apply(SPECIES.length());
2476 
2477         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2478             for (int i = 0; i < a.length; i += SPECIES.length()) {
2479                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2480                 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
2481             }
2482         }
2483 
2484         assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::ASHR_unary);
2485     }
2486 
2487 
2488 
2489     @Test(dataProvider = "shortBinaryOpMaskProvider")
2490     static void ASHRShortMaxVectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2491                                           IntFunction<boolean[]> fm) {
2492         short[] a = fa.apply(SPECIES.length());
2493         short[] b = fb.apply(SPECIES.length());
2494         short[] r = fr.apply(SPECIES.length());
2495         boolean[] mask = fm.apply(SPECIES.length());
2496         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2497 
2498         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2499             for (int i = 0; i < a.length; i += SPECIES.length()) {
2500                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2501                 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
2502             }
2503         }
2504 
2505         assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::ASHR_unary);
2506     }
2507 
2508 
2509     static short ROR(short a, short b) {
2510         return (short)(ROR_scalar(a,b));
2511     }
2512 
2513     @Test(dataProvider = "shortBinaryOpProvider")
2514     static void RORShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2515         short[] a = fa.apply(SPECIES.length());
2516         short[] b = fb.apply(SPECIES.length());
2517         short[] r = fr.apply(SPECIES.length());
2518 
2519         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2520             for (int i = 0; i < a.length; i += SPECIES.length()) {
2521                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2522                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2523                 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
2524             }
2525         }
2526 
2527         assertArraysEquals(r, a, b, ShortMaxVectorTests::ROR);
2528     }
2529 
2530 
2531 
2532     @Test(dataProvider = "shortBinaryOpMaskProvider")
2533     static void RORShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2534                                           IntFunction<boolean[]> fm) {
2535         short[] a = fa.apply(SPECIES.length());
2536         short[] b = fb.apply(SPECIES.length());
2537         short[] r = fr.apply(SPECIES.length());
2538         boolean[] mask = fm.apply(SPECIES.length());
2539         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2540 
2541         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2542             for (int i = 0; i < a.length; i += SPECIES.length()) {
2543                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2544                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2545                 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
2546             }
2547         }
2548 
2549         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROR);
2550     }
2551 
2552 
2553     static short ROL(short a, short b) {
2554         return (short)(ROL_scalar(a,b));
2555     }
2556 
2557     @Test(dataProvider = "shortBinaryOpProvider")
2558     static void ROLShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2559         short[] a = fa.apply(SPECIES.length());
2560         short[] b = fb.apply(SPECIES.length());
2561         short[] r = fr.apply(SPECIES.length());
2562 
2563         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2564             for (int i = 0; i < a.length; i += SPECIES.length()) {
2565                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2566                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2567                 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
2568             }
2569         }
2570 
2571         assertArraysEquals(r, a, b, ShortMaxVectorTests::ROL);
2572     }
2573 
2574 
2575 
2576     @Test(dataProvider = "shortBinaryOpMaskProvider")
2577     static void ROLShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2578                                           IntFunction<boolean[]> fm) {
2579         short[] a = fa.apply(SPECIES.length());
2580         short[] b = fb.apply(SPECIES.length());
2581         short[] r = fr.apply(SPECIES.length());
2582         boolean[] mask = fm.apply(SPECIES.length());
2583         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2584 
2585         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2586             for (int i = 0; i < a.length; i += SPECIES.length()) {
2587                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2588                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2589                 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
2590             }
2591         }
2592 
2593         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROL);
2594     }
2595 
2596 
2597     static short ROR_unary(short a, short b) {
2598         return (short)(ROR_scalar(a, b));
2599     }
2600 
2601     @Test(dataProvider = "shortBinaryOpProvider")
2602     static void RORShortMaxVectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2603         short[] a = fa.apply(SPECIES.length());
2604         short[] b = fb.apply(SPECIES.length());
2605         short[] r = fr.apply(SPECIES.length());
2606 
2607         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2608             for (int i = 0; i < a.length; i += SPECIES.length()) {
2609                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2610                 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
2611             }
2612         }
2613 
2614         assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::ROR_unary);
2615     }
2616 
2617 
2618 
2619     @Test(dataProvider = "shortBinaryOpMaskProvider")
2620     static void RORShortMaxVectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2621                                           IntFunction<boolean[]> fm) {
2622         short[] a = fa.apply(SPECIES.length());
2623         short[] b = fb.apply(SPECIES.length());
2624         short[] r = fr.apply(SPECIES.length());
2625         boolean[] mask = fm.apply(SPECIES.length());
2626         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2627 
2628         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2629             for (int i = 0; i < a.length; i += SPECIES.length()) {
2630                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2631                 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
2632             }
2633         }
2634 
2635         assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROR_unary);
2636     }
2637 
2638 
2639     static short ROL_unary(short a, short b) {
2640         return (short)(ROL_scalar(a, b));
2641     }
2642 
2643     @Test(dataProvider = "shortBinaryOpProvider")
2644     static void ROLShortMaxVectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2645         short[] a = fa.apply(SPECIES.length());
2646         short[] b = fb.apply(SPECIES.length());
2647         short[] r = fr.apply(SPECIES.length());
2648 
2649         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2650             for (int i = 0; i < a.length; i += SPECIES.length()) {
2651                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2652                 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
2653             }
2654         }
2655 
2656         assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::ROL_unary);
2657     }
2658 
2659 
2660 
2661     @Test(dataProvider = "shortBinaryOpMaskProvider")
2662     static void ROLShortMaxVectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2663                                           IntFunction<boolean[]> fm) {
2664         short[] a = fa.apply(SPECIES.length());
2665         short[] b = fb.apply(SPECIES.length());
2666         short[] r = fr.apply(SPECIES.length());
2667         boolean[] mask = fm.apply(SPECIES.length());
2668         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2669 
2670         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2671             for (int i = 0; i < a.length; i += SPECIES.length()) {
2672                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2673                 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
2674             }
2675         }
2676 
2677         assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROL_unary);
2678     }
2679 
2680 
2681 
2682 
2683 
2684 
2685     static short LSHR_binary_const(short a) {
2686         return (short)(((a & 0xFFFF) >>> CONST_SHIFT));
2687     }
2688 
2689     @Test(dataProvider = "shortUnaryOpProvider")
2690     static void LSHRShortMaxVectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2691         short[] a = fa.apply(SPECIES.length());
2692         short[] r = fr.apply(SPECIES.length());
2693 
2694         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2695             for (int i = 0; i < a.length; i += SPECIES.length()) {
2696                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2697                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i);
2698             }
2699         }
2700 
2701         assertShiftConstEquals(r, a, ShortMaxVectorTests::LSHR_binary_const);
2702     }
2703 
2704 
2705 
2706     @Test(dataProvider = "shortUnaryOpMaskProvider")
2707     static void LSHRShortMaxVectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2708                                           IntFunction<boolean[]> fm) {
2709         short[] a = fa.apply(SPECIES.length());
2710         short[] r = fr.apply(SPECIES.length());
2711         boolean[] mask = fm.apply(SPECIES.length());
2712         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2713 
2714         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2715             for (int i = 0; i < a.length; i += SPECIES.length()) {
2716                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2717                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i);
2718             }
2719         }
2720 
2721         assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::LSHR_binary_const);
2722     }
2723 
2724 
2725 
2726     static short LSHL_binary_const(short a) {
2727         return (short)((a << CONST_SHIFT));
2728     }
2729 
2730     @Test(dataProvider = "shortUnaryOpProvider")
2731     static void LSHLShortMaxVectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2732         short[] a = fa.apply(SPECIES.length());
2733         short[] r = fr.apply(SPECIES.length());
2734 
2735         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2736             for (int i = 0; i < a.length; i += SPECIES.length()) {
2737                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2738                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i);
2739             }
2740         }
2741 
2742         assertShiftConstEquals(r, a, ShortMaxVectorTests::LSHL_binary_const);
2743     }
2744 
2745 
2746 
2747     @Test(dataProvider = "shortUnaryOpMaskProvider")
2748     static void LSHLShortMaxVectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2749                                           IntFunction<boolean[]> fm) {
2750         short[] a = fa.apply(SPECIES.length());
2751         short[] r = fr.apply(SPECIES.length());
2752         boolean[] mask = fm.apply(SPECIES.length());
2753         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2754 
2755         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2756             for (int i = 0; i < a.length; i += SPECIES.length()) {
2757                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2758                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i);
2759             }
2760         }
2761 
2762         assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::LSHL_binary_const);
2763     }
2764 
2765 
2766 
2767     static short ASHR_binary_const(short a) {
2768         return (short)((a >> CONST_SHIFT));
2769     }
2770 
2771     @Test(dataProvider = "shortUnaryOpProvider")
2772     static void ASHRShortMaxVectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2773         short[] a = fa.apply(SPECIES.length());
2774         short[] r = fr.apply(SPECIES.length());
2775 
2776         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2777             for (int i = 0; i < a.length; i += SPECIES.length()) {
2778                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2779                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i);
2780             }
2781         }
2782 
2783         assertShiftConstEquals(r, a, ShortMaxVectorTests::ASHR_binary_const);
2784     }
2785 
2786 
2787 
2788     @Test(dataProvider = "shortUnaryOpMaskProvider")
2789     static void ASHRShortMaxVectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2790                                           IntFunction<boolean[]> fm) {
2791         short[] a = fa.apply(SPECIES.length());
2792         short[] r = fr.apply(SPECIES.length());
2793         boolean[] mask = fm.apply(SPECIES.length());
2794         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2795 
2796         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2797             for (int i = 0; i < a.length; i += SPECIES.length()) {
2798                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2799                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i);
2800             }
2801         }
2802 
2803         assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::ASHR_binary_const);
2804     }
2805 
2806 
2807 
2808     static short ROR_binary_const(short a) {
2809         return (short)(ROR_scalar(a, CONST_SHIFT));
2810     }
2811 
2812     @Test(dataProvider = "shortUnaryOpProvider")
2813     static void RORShortMaxVectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2814         short[] a = fa.apply(SPECIES.length());
2815         short[] r = fr.apply(SPECIES.length());
2816 
2817         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2818             for (int i = 0; i < a.length; i += SPECIES.length()) {
2819                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2820                 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i);
2821             }
2822         }
2823 
2824         assertShiftConstEquals(r, a, ShortMaxVectorTests::ROR_binary_const);
2825     }
2826 
2827 
2828 
2829     @Test(dataProvider = "shortUnaryOpMaskProvider")
2830     static void RORShortMaxVectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2831                                           IntFunction<boolean[]> fm) {
2832         short[] a = fa.apply(SPECIES.length());
2833         short[] r = fr.apply(SPECIES.length());
2834         boolean[] mask = fm.apply(SPECIES.length());
2835         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2836 
2837         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2838             for (int i = 0; i < a.length; i += SPECIES.length()) {
2839                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2840                 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i);
2841             }
2842         }
2843 
2844         assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::ROR_binary_const);
2845     }
2846 
2847 
2848 
2849     static short ROL_binary_const(short a) {
2850         return (short)(ROL_scalar(a, CONST_SHIFT));
2851     }
2852 
2853     @Test(dataProvider = "shortUnaryOpProvider")
2854     static void ROLShortMaxVectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2855         short[] a = fa.apply(SPECIES.length());
2856         short[] r = fr.apply(SPECIES.length());
2857 
2858         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2859             for (int i = 0; i < a.length; i += SPECIES.length()) {
2860                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2861                 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i);
2862             }
2863         }
2864 
2865         assertShiftConstEquals(r, a, ShortMaxVectorTests::ROL_binary_const);
2866     }
2867 
2868 
2869 
2870     @Test(dataProvider = "shortUnaryOpMaskProvider")
2871     static void ROLShortMaxVectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2872                                           IntFunction<boolean[]> fm) {
2873         short[] a = fa.apply(SPECIES.length());
2874         short[] r = fr.apply(SPECIES.length());
2875         boolean[] mask = fm.apply(SPECIES.length());
2876         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2877 
2878         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2879             for (int i = 0; i < a.length; i += SPECIES.length()) {
2880                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2881                 av.lanewise(VectorOperators.ROL, CONST_SHIFT, vmask).intoArray(r, i);
2882             }
2883         }
2884 
2885         assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::ROL_binary_const);
2886     }
2887 
2888 
2889     static short MIN(short a, short b) {
2890         return (short)(Math.min(a, b));
2891     }
2892 
2893     @Test(dataProvider = "shortBinaryOpProvider")
2894     static void MINShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2895         short[] a = fa.apply(SPECIES.length());
2896         short[] b = fb.apply(SPECIES.length());
2897         short[] r = fr.apply(SPECIES.length());
2898 
2899         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2900             for (int i = 0; i < a.length; i += SPECIES.length()) {
2901                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2902                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2903                 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
2904             }
2905         }
2906 
2907         assertArraysEquals(r, a, b, ShortMaxVectorTests::MIN);
2908     }

2909     static short min(short a, short b) {
2910         return (short)(Math.min(a, b));
2911     }
2912 
2913     @Test(dataProvider = "shortBinaryOpProvider")
2914     static void minShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2915         short[] a = fa.apply(SPECIES.length());
2916         short[] b = fb.apply(SPECIES.length());
2917         short[] r = fr.apply(SPECIES.length());
2918 
2919         for (int i = 0; i < a.length; i += SPECIES.length()) {
2920             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2921             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2922             av.min(bv).intoArray(r, i);
2923         }
2924 
2925         assertArraysEquals(r, a, b, ShortMaxVectorTests::min);
2926     }

2927     static short MAX(short a, short b) {
2928         return (short)(Math.max(a, b));
2929     }
2930 
2931     @Test(dataProvider = "shortBinaryOpProvider")
2932     static void MAXShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2933         short[] a = fa.apply(SPECIES.length());
2934         short[] b = fb.apply(SPECIES.length());
2935         short[] r = fr.apply(SPECIES.length());
2936 
2937         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2938             for (int i = 0; i < a.length; i += SPECIES.length()) {
2939                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2940                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2941                 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
2942             }
2943         }
2944 
2945         assertArraysEquals(r, a, b, ShortMaxVectorTests::MAX);
2946     }

2947     static short max(short a, short b) {
2948         return (short)(Math.max(a, b));
2949     }
2950 
2951     @Test(dataProvider = "shortBinaryOpProvider")
2952     static void maxShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2953         short[] a = fa.apply(SPECIES.length());
2954         short[] b = fb.apply(SPECIES.length());
2955         short[] r = fr.apply(SPECIES.length());
2956 
2957         for (int i = 0; i < a.length; i += SPECIES.length()) {
2958             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2959             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2960             av.max(bv).intoArray(r, i);
2961         }
2962 
2963         assertArraysEquals(r, a, b, ShortMaxVectorTests::max);
2964     }
2965 
2966     @Test(dataProvider = "shortBinaryOpProvider")
2967     static void MINShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2968         short[] a = fa.apply(SPECIES.length());
2969         short[] b = fb.apply(SPECIES.length());
2970         short[] r = fr.apply(SPECIES.length());
2971 
2972         for (int i = 0; i < a.length; i += SPECIES.length()) {
2973             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2974             av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
2975         }
2976 
2977         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::MIN);
2978     }
2979 
2980     @Test(dataProvider = "shortBinaryOpProvider")
2981     static void minShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2982         short[] a = fa.apply(SPECIES.length());
2983         short[] b = fb.apply(SPECIES.length());
2984         short[] r = fr.apply(SPECIES.length());
2985 
2986         for (int i = 0; i < a.length; i += SPECIES.length()) {
2987             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2988             av.min(b[i]).intoArray(r, i);
2989         }
2990 
2991         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::min);
2992     }
2993 
2994     @Test(dataProvider = "shortBinaryOpProvider")
2995     static void MAXShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2996         short[] a = fa.apply(SPECIES.length());
2997         short[] b = fb.apply(SPECIES.length());
2998         short[] r = fr.apply(SPECIES.length());
2999 
3000         for (int i = 0; i < a.length; i += SPECIES.length()) {
3001             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3002             av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
3003         }
3004 
3005         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::MAX);
3006     }
3007 
3008     @Test(dataProvider = "shortBinaryOpProvider")
3009     static void maxShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3010         short[] a = fa.apply(SPECIES.length());
3011         short[] b = fb.apply(SPECIES.length());
3012         short[] r = fr.apply(SPECIES.length());
3013 
3014         for (int i = 0; i < a.length; i += SPECIES.length()) {
3015             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3016             av.max(b[i]).intoArray(r, i);
3017         }
3018 
3019         assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::max);
3020     }
3021 
3022     static short ANDReduce(short[] a, int idx) {
3023         short res = -1;
3024         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3025             res &= a[i];
3026         }
3027 
3028         return res;
3029     }
3030 
3031     static short ANDReduceAll(short[] a) {
3032         short res = -1;
3033         for (int i = 0; i < a.length; i += SPECIES.length()) {
3034             res &= ANDReduce(a, i);
3035         }
3036 
3037         return res;
3038     }
3039 
3040 
3041     @Test(dataProvider = "shortUnaryOpProvider")
3042     static void ANDReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3043         short[] a = fa.apply(SPECIES.length());
3044         short[] r = fr.apply(SPECIES.length());
3045         short ra = -1;
3046 
3047         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3048             for (int i = 0; i < a.length; i += SPECIES.length()) {
3049                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3050                 r[i] = av.reduceLanes(VectorOperators.AND);
3051             }
3052         }
3053 
3054         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3055             ra = -1;
3056             for (int i = 0; i < a.length; i += SPECIES.length()) {
3057                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3058                 ra &= av.reduceLanes(VectorOperators.AND);
3059             }
3060         }
3061 
3062         assertReductionArraysEquals(r, ra, a,
3063                 ShortMaxVectorTests::ANDReduce, ShortMaxVectorTests::ANDReduceAll);
3064     }
3065 
3066 
3067     static short ANDReduceMasked(short[] a, int idx, boolean[] mask) {
3068         short res = -1;
3069         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3070             if (mask[i % SPECIES.length()])
3071                 res &= a[i];
3072         }
3073 
3074         return res;
3075     }
3076 
3077     static short ANDReduceAllMasked(short[] a, boolean[] mask) {
3078         short res = -1;
3079         for (int i = 0; i < a.length; i += SPECIES.length()) {
3080             res &= ANDReduceMasked(a, i, mask);
3081         }
3082 
3083         return res;
3084     }
3085 
3086 
3087     @Test(dataProvider = "shortUnaryOpMaskProvider")
3088     static void ANDReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3089         short[] a = fa.apply(SPECIES.length());
3090         short[] r = fr.apply(SPECIES.length());
3091         boolean[] mask = fm.apply(SPECIES.length());
3092         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3093         short ra = -1;
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                 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
3099             }
3100         }
3101 
3102         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3103             ra = -1;
3104             for (int i = 0; i < a.length; i += SPECIES.length()) {
3105                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3106                 ra &= av.reduceLanes(VectorOperators.AND, vmask);
3107             }
3108         }
3109 
3110         assertReductionArraysEqualsMasked(r, ra, a, mask,
3111                 ShortMaxVectorTests::ANDReduceMasked, ShortMaxVectorTests::ANDReduceAllMasked);
3112     }
3113 
3114 
3115     static short ORReduce(short[] a, int idx) {
3116         short res = 0;
3117         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3118             res |= a[i];
3119         }
3120 
3121         return res;
3122     }
3123 
3124     static short ORReduceAll(short[] a) {
3125         short res = 0;
3126         for (int i = 0; i < a.length; i += SPECIES.length()) {
3127             res |= ORReduce(a, i);
3128         }
3129 
3130         return res;
3131     }
3132 
3133 
3134     @Test(dataProvider = "shortUnaryOpProvider")
3135     static void ORReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3136         short[] a = fa.apply(SPECIES.length());
3137         short[] r = fr.apply(SPECIES.length());
3138         short ra = 0;
3139 
3140         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3141             for (int i = 0; i < a.length; i += SPECIES.length()) {
3142                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3143                 r[i] = av.reduceLanes(VectorOperators.OR);
3144             }
3145         }
3146 
3147         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3148             ra = 0;
3149             for (int i = 0; i < a.length; i += SPECIES.length()) {
3150                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3151                 ra |= av.reduceLanes(VectorOperators.OR);
3152             }
3153         }
3154 
3155         assertReductionArraysEquals(r, ra, a,
3156                 ShortMaxVectorTests::ORReduce, ShortMaxVectorTests::ORReduceAll);
3157     }
3158 
3159 
3160     static short ORReduceMasked(short[] a, int idx, boolean[] mask) {
3161         short res = 0;
3162         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3163             if (mask[i % SPECIES.length()])
3164                 res |= a[i];
3165         }
3166 
3167         return res;
3168     }
3169 
3170     static short ORReduceAllMasked(short[] a, boolean[] mask) {
3171         short res = 0;
3172         for (int i = 0; i < a.length; i += SPECIES.length()) {
3173             res |= ORReduceMasked(a, i, mask);
3174         }
3175 
3176         return res;
3177     }
3178 
3179 
3180     @Test(dataProvider = "shortUnaryOpMaskProvider")
3181     static void ORReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3182         short[] a = fa.apply(SPECIES.length());
3183         short[] r = fr.apply(SPECIES.length());
3184         boolean[] mask = fm.apply(SPECIES.length());
3185         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3186         short ra = 0;
3187 
3188         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3189             for (int i = 0; i < a.length; i += SPECIES.length()) {
3190                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3191                 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
3192             }
3193         }
3194 
3195         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3196             ra = 0;
3197             for (int i = 0; i < a.length; i += SPECIES.length()) {
3198                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3199                 ra |= av.reduceLanes(VectorOperators.OR, vmask);
3200             }
3201         }
3202 
3203         assertReductionArraysEqualsMasked(r, ra, a, mask,
3204                 ShortMaxVectorTests::ORReduceMasked, ShortMaxVectorTests::ORReduceAllMasked);
3205     }
3206 
3207 
3208     static short XORReduce(short[] a, int idx) {
3209         short res = 0;
3210         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3211             res ^= a[i];
3212         }
3213 
3214         return res;
3215     }
3216 
3217     static short XORReduceAll(short[] a) {
3218         short res = 0;
3219         for (int i = 0; i < a.length; i += SPECIES.length()) {
3220             res ^= XORReduce(a, i);
3221         }
3222 
3223         return res;
3224     }
3225 
3226 
3227     @Test(dataProvider = "shortUnaryOpProvider")
3228     static void XORReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3229         short[] a = fa.apply(SPECIES.length());
3230         short[] r = fr.apply(SPECIES.length());
3231         short ra = 0;
3232 
3233         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3234             for (int i = 0; i < a.length; i += SPECIES.length()) {
3235                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3236                 r[i] = av.reduceLanes(VectorOperators.XOR);
3237             }
3238         }
3239 
3240         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3241             ra = 0;
3242             for (int i = 0; i < a.length; i += SPECIES.length()) {
3243                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3244                 ra ^= av.reduceLanes(VectorOperators.XOR);
3245             }
3246         }
3247 
3248         assertReductionArraysEquals(r, ra, a,
3249                 ShortMaxVectorTests::XORReduce, ShortMaxVectorTests::XORReduceAll);
3250     }
3251 
3252 
3253     static short XORReduceMasked(short[] a, int idx, boolean[] mask) {
3254         short res = 0;
3255         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3256             if (mask[i % SPECIES.length()])
3257                 res ^= a[i];
3258         }
3259 
3260         return res;
3261     }
3262 
3263     static short XORReduceAllMasked(short[] a, boolean[] mask) {
3264         short res = 0;
3265         for (int i = 0; i < a.length; i += SPECIES.length()) {
3266             res ^= XORReduceMasked(a, i, mask);
3267         }
3268 
3269         return res;
3270     }
3271 
3272 
3273     @Test(dataProvider = "shortUnaryOpMaskProvider")
3274     static void XORReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3275         short[] a = fa.apply(SPECIES.length());
3276         short[] r = fr.apply(SPECIES.length());
3277         boolean[] mask = fm.apply(SPECIES.length());
3278         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3279         short ra = 0;
3280 
3281         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3282             for (int i = 0; i < a.length; i += SPECIES.length()) {
3283                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3284                 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
3285             }
3286         }
3287 
3288         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3289             ra = 0;
3290             for (int i = 0; i < a.length; i += SPECIES.length()) {
3291                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3292                 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
3293             }
3294         }
3295 
3296         assertReductionArraysEqualsMasked(r, ra, a, mask,
3297                 ShortMaxVectorTests::XORReduceMasked, ShortMaxVectorTests::XORReduceAllMasked);
3298     }
3299 
3300     static short ADDReduce(short[] a, int idx) {
3301         short res = 0;
3302         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3303             res += a[i];
3304         }
3305 
3306         return res;
3307     }
3308 
3309     static short ADDReduceAll(short[] a) {
3310         short res = 0;
3311         for (int i = 0; i < a.length; i += SPECIES.length()) {
3312             res += ADDReduce(a, i);
3313         }
3314 
3315         return res;
3316     }

3317     @Test(dataProvider = "shortUnaryOpProvider")
3318     static void ADDReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3319         short[] a = fa.apply(SPECIES.length());
3320         short[] r = fr.apply(SPECIES.length());
3321         short ra = 0;
3322 
3323         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3324             for (int i = 0; i < a.length; i += SPECIES.length()) {
3325                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3326                 r[i] = av.reduceLanes(VectorOperators.ADD);
3327             }
3328         }
3329 
3330         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3331             ra = 0;
3332             for (int i = 0; i < a.length; i += SPECIES.length()) {
3333                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3334                 ra += av.reduceLanes(VectorOperators.ADD);
3335             }
3336         }
3337 
3338         assertReductionArraysEquals(r, ra, a,
3339                 ShortMaxVectorTests::ADDReduce, ShortMaxVectorTests::ADDReduceAll);
3340     }

3341     static short ADDReduceMasked(short[] a, int idx, boolean[] mask) {
3342         short res = 0;
3343         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3344             if (mask[i % SPECIES.length()])
3345                 res += a[i];
3346         }
3347 
3348         return res;
3349     }
3350 
3351     static short ADDReduceAllMasked(short[] a, boolean[] mask) {
3352         short res = 0;
3353         for (int i = 0; i < a.length; i += SPECIES.length()) {
3354             res += ADDReduceMasked(a, i, mask);
3355         }
3356 
3357         return res;
3358     }

3359     @Test(dataProvider = "shortUnaryOpMaskProvider")
3360     static void ADDReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3361         short[] a = fa.apply(SPECIES.length());
3362         short[] r = fr.apply(SPECIES.length());
3363         boolean[] mask = fm.apply(SPECIES.length());
3364         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3365         short ra = 0;
3366 
3367         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3368             for (int i = 0; i < a.length; i += SPECIES.length()) {
3369                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3370                 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
3371             }
3372         }
3373 
3374         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3375             ra = 0;
3376             for (int i = 0; i < a.length; i += SPECIES.length()) {
3377                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3378                 ra += av.reduceLanes(VectorOperators.ADD, vmask);
3379             }
3380         }
3381 
3382         assertReductionArraysEqualsMasked(r, ra, a, mask,
3383                 ShortMaxVectorTests::ADDReduceMasked, ShortMaxVectorTests::ADDReduceAllMasked);
3384     }

3385     static short MULReduce(short[] a, int idx) {
3386         short res = 1;
3387         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3388             res *= a[i];
3389         }
3390 
3391         return res;
3392     }
3393 
3394     static short MULReduceAll(short[] a) {
3395         short res = 1;
3396         for (int i = 0; i < a.length; i += SPECIES.length()) {
3397             res *= MULReduce(a, i);
3398         }
3399 
3400         return res;
3401     }

3402     @Test(dataProvider = "shortUnaryOpProvider")
3403     static void MULReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3404         short[] a = fa.apply(SPECIES.length());
3405         short[] r = fr.apply(SPECIES.length());
3406         short ra = 1;
3407 
3408         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3409             for (int i = 0; i < a.length; i += SPECIES.length()) {
3410                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3411                 r[i] = av.reduceLanes(VectorOperators.MUL);
3412             }
3413         }
3414 
3415         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3416             ra = 1;
3417             for (int i = 0; i < a.length; i += SPECIES.length()) {
3418                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3419                 ra *= av.reduceLanes(VectorOperators.MUL);
3420             }
3421         }
3422 
3423         assertReductionArraysEquals(r, ra, a,
3424                 ShortMaxVectorTests::MULReduce, ShortMaxVectorTests::MULReduceAll);
3425     }

3426     static short MULReduceMasked(short[] a, int idx, boolean[] mask) {
3427         short res = 1;
3428         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3429             if (mask[i % SPECIES.length()])
3430                 res *= a[i];
3431         }
3432 
3433         return res;
3434     }
3435 
3436     static short MULReduceAllMasked(short[] a, boolean[] mask) {
3437         short res = 1;
3438         for (int i = 0; i < a.length; i += SPECIES.length()) {
3439             res *= MULReduceMasked(a, i, mask);
3440         }
3441 
3442         return res;
3443     }

3444     @Test(dataProvider = "shortUnaryOpMaskProvider")
3445     static void MULReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3446         short[] a = fa.apply(SPECIES.length());
3447         short[] r = fr.apply(SPECIES.length());
3448         boolean[] mask = fm.apply(SPECIES.length());
3449         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3450         short ra = 1;
3451 
3452         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3453             for (int i = 0; i < a.length; i += SPECIES.length()) {
3454                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3455                 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
3456             }
3457         }
3458 
3459         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3460             ra = 1;
3461             for (int i = 0; i < a.length; i += SPECIES.length()) {
3462                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3463                 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
3464             }
3465         }
3466 
3467         assertReductionArraysEqualsMasked(r, ra, a, mask,
3468                 ShortMaxVectorTests::MULReduceMasked, ShortMaxVectorTests::MULReduceAllMasked);
3469     }

3470     static short MINReduce(short[] a, int idx) {
3471         short res = Short.MAX_VALUE;
3472         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3473             res = (short) Math.min(res, a[i]);
3474         }
3475 
3476         return res;
3477     }
3478 
3479     static short MINReduceAll(short[] a) {
3480         short res = Short.MAX_VALUE;
3481         for (int i = 0; i < a.length; i += SPECIES.length()) {
3482             res = (short) Math.min(res, MINReduce(a, i));
3483         }
3484 
3485         return res;
3486     }

3487     @Test(dataProvider = "shortUnaryOpProvider")
3488     static void MINReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3489         short[] a = fa.apply(SPECIES.length());
3490         short[] r = fr.apply(SPECIES.length());
3491         short ra = Short.MAX_VALUE;
3492 
3493         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3494             for (int i = 0; i < a.length; i += SPECIES.length()) {
3495                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3496                 r[i] = av.reduceLanes(VectorOperators.MIN);
3497             }
3498         }
3499 
3500         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3501             ra = Short.MAX_VALUE;
3502             for (int i = 0; i < a.length; i += SPECIES.length()) {
3503                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3504                 ra = (short) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
3505             }
3506         }
3507 
3508         assertReductionArraysEquals(r, ra, a,
3509                 ShortMaxVectorTests::MINReduce, ShortMaxVectorTests::MINReduceAll);
3510     }

3511     static short MINReduceMasked(short[] a, int idx, boolean[] mask) {
3512         short res = Short.MAX_VALUE;
3513         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3514             if (mask[i % SPECIES.length()])
3515                 res = (short) Math.min(res, a[i]);
3516         }
3517 
3518         return res;
3519     }
3520 
3521     static short MINReduceAllMasked(short[] a, boolean[] mask) {
3522         short res = Short.MAX_VALUE;
3523         for (int i = 0; i < a.length; i += SPECIES.length()) {
3524             res = (short) Math.min(res, MINReduceMasked(a, i, mask));
3525         }
3526 
3527         return res;
3528     }

3529     @Test(dataProvider = "shortUnaryOpMaskProvider")
3530     static void MINReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3531         short[] a = fa.apply(SPECIES.length());
3532         short[] r = fr.apply(SPECIES.length());
3533         boolean[] mask = fm.apply(SPECIES.length());
3534         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3535         short ra = Short.MAX_VALUE;
3536 
3537         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3538             for (int i = 0; i < a.length; i += SPECIES.length()) {
3539                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3540                 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
3541             }
3542         }
3543 
3544         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3545             ra = Short.MAX_VALUE;
3546             for (int i = 0; i < a.length; i += SPECIES.length()) {
3547                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3548                 ra = (short) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
3549             }
3550         }
3551 
3552         assertReductionArraysEqualsMasked(r, ra, a, mask,
3553                 ShortMaxVectorTests::MINReduceMasked, ShortMaxVectorTests::MINReduceAllMasked);
3554     }

3555     static short MAXReduce(short[] a, int idx) {
3556         short res = Short.MIN_VALUE;
3557         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3558             res = (short) Math.max(res, a[i]);
3559         }
3560 
3561         return res;
3562     }
3563 
3564     static short MAXReduceAll(short[] a) {
3565         short res = Short.MIN_VALUE;
3566         for (int i = 0; i < a.length; i += SPECIES.length()) {
3567             res = (short) Math.max(res, MAXReduce(a, i));
3568         }
3569 
3570         return res;
3571     }

3572     @Test(dataProvider = "shortUnaryOpProvider")
3573     static void MAXReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3574         short[] a = fa.apply(SPECIES.length());
3575         short[] r = fr.apply(SPECIES.length());
3576         short ra = Short.MIN_VALUE;
3577 
3578         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3579             for (int i = 0; i < a.length; i += SPECIES.length()) {
3580                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3581                 r[i] = av.reduceLanes(VectorOperators.MAX);
3582             }
3583         }
3584 
3585         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3586             ra = Short.MIN_VALUE;
3587             for (int i = 0; i < a.length; i += SPECIES.length()) {
3588                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3589                 ra = (short) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
3590             }
3591         }
3592 
3593         assertReductionArraysEquals(r, ra, a,
3594                 ShortMaxVectorTests::MAXReduce, ShortMaxVectorTests::MAXReduceAll);
3595     }

3596     static short MAXReduceMasked(short[] a, int idx, boolean[] mask) {
3597         short res = Short.MIN_VALUE;
3598         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3599             if (mask[i % SPECIES.length()])
3600                 res = (short) Math.max(res, a[i]);
3601         }
3602 
3603         return res;
3604     }
3605 
3606     static short MAXReduceAllMasked(short[] a, boolean[] mask) {
3607         short res = Short.MIN_VALUE;
3608         for (int i = 0; i < a.length; i += SPECIES.length()) {
3609             res = (short) Math.max(res, MAXReduceMasked(a, i, mask));
3610         }
3611 
3612         return res;
3613     }

3614     @Test(dataProvider = "shortUnaryOpMaskProvider")
3615     static void MAXReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3616         short[] a = fa.apply(SPECIES.length());
3617         short[] r = fr.apply(SPECIES.length());
3618         boolean[] mask = fm.apply(SPECIES.length());
3619         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3620         short ra = Short.MIN_VALUE;
3621 
3622         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3623             for (int i = 0; i < a.length; i += SPECIES.length()) {
3624                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3625                 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
3626             }
3627         }
3628 
3629         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3630             ra = Short.MIN_VALUE;
3631             for (int i = 0; i < a.length; i += SPECIES.length()) {
3632                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3633                 ra = (short) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
3634             }
3635         }
3636 
3637         assertReductionArraysEqualsMasked(r, ra, a, mask,
3638                 ShortMaxVectorTests::MAXReduceMasked, ShortMaxVectorTests::MAXReduceAllMasked);
3639     }

3640     static short FIRST_NONZEROReduce(short[] a, int idx) {
3641         short res = (short) 0;
3642         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3643             res = firstNonZero(res, a[i]);
3644         }
3645 
3646         return res;
3647     }
3648 
3649     static short FIRST_NONZEROReduceAll(short[] a) {
3650         short res = (short) 0;
3651         for (int i = 0; i < a.length; i += SPECIES.length()) {
3652             res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
3653         }
3654 
3655         return res;
3656     }

3657     @Test(dataProvider = "shortUnaryOpProvider")
3658     static void FIRST_NONZEROReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3659         short[] a = fa.apply(SPECIES.length());
3660         short[] r = fr.apply(SPECIES.length());
3661         short ra = (short) 0;
3662 
3663         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3664             for (int i = 0; i < a.length; i += SPECIES.length()) {
3665                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3666                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
3667             }
3668         }
3669 
3670         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3671             ra = (short) 0;
3672             for (int i = 0; i < a.length; i += SPECIES.length()) {
3673                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3674                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
3675             }
3676         }
3677 
3678         assertReductionArraysEquals(r, ra, a,
3679                 ShortMaxVectorTests::FIRST_NONZEROReduce, ShortMaxVectorTests::FIRST_NONZEROReduceAll);
3680     }

3681     static short FIRST_NONZEROReduceMasked(short[] a, int idx, boolean[] mask) {
3682         short res = (short) 0;
3683         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3684             if (mask[i % SPECIES.length()])
3685                 res = firstNonZero(res, a[i]);
3686         }
3687 
3688         return res;
3689     }
3690 
3691     static short FIRST_NONZEROReduceAllMasked(short[] a, boolean[] mask) {
3692         short res = (short) 0;
3693         for (int i = 0; i < a.length; i += SPECIES.length()) {
3694             res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
3695         }
3696 
3697         return res;
3698     }

3699     @Test(dataProvider = "shortUnaryOpMaskProvider")
3700     static void FIRST_NONZEROReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3701         short[] a = fa.apply(SPECIES.length());
3702         short[] r = fr.apply(SPECIES.length());
3703         boolean[] mask = fm.apply(SPECIES.length());
3704         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3705         short ra = (short) 0;
3706 
3707         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3708             for (int i = 0; i < a.length; i += SPECIES.length()) {
3709                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3710                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
3711             }
3712         }
3713 
3714         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3715             ra = (short) 0;
3716             for (int i = 0; i < a.length; i += SPECIES.length()) {
3717                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3718                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
3719             }
3720         }
3721 
3722         assertReductionArraysEqualsMasked(r, ra, a, mask,
3723                 ShortMaxVectorTests::FIRST_NONZEROReduceMasked, ShortMaxVectorTests::FIRST_NONZEROReduceAllMasked);
3724     }
3725 
3726     static boolean anyTrue(boolean[] a, int idx) {
3727         boolean res = false;
3728         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3729             res |= a[i];
3730         }
3731 
3732         return res;
3733     }
3734 
3735 
3736     @Test(dataProvider = "boolUnaryOpProvider")
3737     static void anyTrueShortMaxVectorTests(IntFunction<boolean[]> fm) {
3738         boolean[] mask = fm.apply(SPECIES.length());
3739         boolean[] r = fmr.apply(SPECIES.length());
3740 
3741         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3742             for (int i = 0; i < mask.length; i += SPECIES.length()) {
3743                 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
3744                 r[i] = vmask.anyTrue();
3745             }
3746         }
3747 
3748         assertReductionBoolArraysEquals(r, mask, ShortMaxVectorTests::anyTrue);
3749     }
3750 
3751 
3752     static boolean allTrue(boolean[] a, int idx) {
3753         boolean res = true;
3754         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3755             res &= a[i];
3756         }
3757 
3758         return res;
3759     }
3760 
3761 
3762     @Test(dataProvider = "boolUnaryOpProvider")
3763     static void allTrueShortMaxVectorTests(IntFunction<boolean[]> fm) {
3764         boolean[] mask = fm.apply(SPECIES.length());
3765         boolean[] r = fmr.apply(SPECIES.length());
3766 
3767         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3768             for (int i = 0; i < mask.length; i += SPECIES.length()) {
3769                 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
3770                 r[i] = vmask.allTrue();
3771             }
3772         }
3773 
3774         assertReductionBoolArraysEquals(r, mask, ShortMaxVectorTests::allTrue);
3775     }
3776 
3777 
3778     @Test(dataProvider = "shortUnaryOpProvider")
3779     static void withShortMaxVectorTests(IntFunction<short []> fa) {
3780         short[] a = fa.apply(SPECIES.length());
3781         short[] r = fr.apply(SPECIES.length());
3782 
3783         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3784             for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
3785                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3786                 av.withLane((j++ & (SPECIES.length()-1)), (short)(65535+i)).intoArray(r, i);
3787             }
3788         }
3789 
3790 
3791         for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
3792             assertInsertArraysEquals(r, a, (short)(65535+i), (j++ & (SPECIES.length()-1)), i , i + SPECIES.length());
3793         }
3794     }

3795     static boolean testIS_DEFAULT(short a) {
3796         return bits(a)==0;
3797     }
3798 
3799     @Test(dataProvider = "shortTestOpProvider")
3800     static void IS_DEFAULTShortMaxVectorTests(IntFunction<short[]> fa) {
3801         short[] a = fa.apply(SPECIES.length());
3802 
3803         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3804             for (int i = 0; i < a.length; i += SPECIES.length()) {
3805                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3806                 VectorMask<Short> mv = av.test(VectorOperators.IS_DEFAULT);
3807 
3808                 // Check results as part of computation.
3809                 for (int j = 0; j < SPECIES.length(); j++) {
3810                     Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
3811                 }
3812             }
3813         }
3814     }
3815 
3816     @Test(dataProvider = "shortTestOpMaskProvider")
3817     static void IS_DEFAULTMaskedShortMaxVectorTests(IntFunction<short[]> fa,
3818                                           IntFunction<boolean[]> fm) {
3819         short[] a = fa.apply(SPECIES.length());
3820         boolean[] mask = fm.apply(SPECIES.length());
3821         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3822 
3823         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3824             for (int i = 0; i < a.length; i += SPECIES.length()) {
3825                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3826                 VectorMask<Short> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
3827 
3828                 // Check results as part of computation.
3829                 for (int j = 0; j < SPECIES.length(); j++) {
3830                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
3831                 }
3832             }
3833         }
3834     }

3835     static boolean testIS_NEGATIVE(short a) {
3836         return bits(a)<0;
3837     }
3838 
3839     @Test(dataProvider = "shortTestOpProvider")
3840     static void IS_NEGATIVEShortMaxVectorTests(IntFunction<short[]> fa) {
3841         short[] a = fa.apply(SPECIES.length());
3842 
3843         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3844             for (int i = 0; i < a.length; i += SPECIES.length()) {
3845                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3846                 VectorMask<Short> mv = av.test(VectorOperators.IS_NEGATIVE);
3847 
3848                 // Check results as part of computation.
3849                 for (int j = 0; j < SPECIES.length(); j++) {
3850                     Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
3851                 }
3852             }
3853         }
3854     }
3855 
3856     @Test(dataProvider = "shortTestOpMaskProvider")
3857     static void IS_NEGATIVEMaskedShortMaxVectorTests(IntFunction<short[]> fa,
3858                                           IntFunction<boolean[]> fm) {
3859         short[] a = fa.apply(SPECIES.length());
3860         boolean[] mask = fm.apply(SPECIES.length());
3861         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3862 
3863         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3864             for (int i = 0; i < a.length; i += SPECIES.length()) {
3865                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3866                 VectorMask<Short> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
3867 
3868                 // Check results as part of computation.
3869                 for (int j = 0; j < SPECIES.length(); j++) {
3870                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
3871                 }
3872             }
3873         }
3874     }
3875 
3876 
3877 
3878 
3879     @Test(dataProvider = "shortCompareOpProvider")
3880     static void LTShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3881         short[] a = fa.apply(SPECIES.length());
3882         short[] b = fb.apply(SPECIES.length());
3883 
3884         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3885             for (int i = 0; i < a.length; i += SPECIES.length()) {
3886                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3887                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3888                 VectorMask<Short> mv = av.compare(VectorOperators.LT, bv);
3889 
3890                 // Check results as part of computation.
3891                 for (int j = 0; j < SPECIES.length(); j++) {
3892                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3893                 }
3894             }
3895         }
3896     }
3897 
3898 
3899     @Test(dataProvider = "shortCompareOpProvider")
3900     static void ltShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3901         short[] a = fa.apply(SPECIES.length());
3902         short[] b = fb.apply(SPECIES.length());
3903 
3904         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3905             for (int i = 0; i < a.length; i += SPECIES.length()) {
3906                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3907                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3908                 VectorMask<Short> mv = av.lt(bv);
3909 
3910                 // Check results as part of computation.
3911                 for (int j = 0; j < SPECIES.length(); j++) {
3912                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3913                 }
3914             }
3915         }
3916     }
3917 
3918     @Test(dataProvider = "shortCompareOpMaskProvider")
3919     static void LTShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3920                                                 IntFunction<boolean[]> fm) {
3921         short[] a = fa.apply(SPECIES.length());
3922         short[] b = fb.apply(SPECIES.length());
3923         boolean[] mask = fm.apply(SPECIES.length());
3924 
3925         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3926 
3927         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3928             for (int i = 0; i < a.length; i += SPECIES.length()) {
3929                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3930                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3931                 VectorMask<Short> mv = av.compare(VectorOperators.LT, bv, vmask);
3932 
3933                 // Check results as part of computation.
3934                 for (int j = 0; j < SPECIES.length(); j++) {
3935                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
3936                 }
3937             }
3938         }
3939     }
3940 
3941 
3942     @Test(dataProvider = "shortCompareOpProvider")
3943     static void GTShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3944         short[] a = fa.apply(SPECIES.length());
3945         short[] b = fb.apply(SPECIES.length());
3946 
3947         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3948             for (int i = 0; i < a.length; i += SPECIES.length()) {
3949                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3950                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3951                 VectorMask<Short> mv = av.compare(VectorOperators.GT, bv);
3952 
3953                 // Check results as part of computation.
3954                 for (int j = 0; j < SPECIES.length(); j++) {
3955                     Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
3956                 }
3957             }
3958         }
3959     }
3960 
3961     @Test(dataProvider = "shortCompareOpMaskProvider")
3962     static void GTShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3963                                                 IntFunction<boolean[]> fm) {
3964         short[] a = fa.apply(SPECIES.length());
3965         short[] b = fb.apply(SPECIES.length());
3966         boolean[] mask = fm.apply(SPECIES.length());
3967 
3968         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3969 
3970         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3971             for (int i = 0; i < a.length; i += SPECIES.length()) {
3972                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3973                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3974                 VectorMask<Short> mv = av.compare(VectorOperators.GT, bv, vmask);
3975 
3976                 // Check results as part of computation.
3977                 for (int j = 0; j < SPECIES.length(); j++) {
3978                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
3979                 }
3980             }
3981         }
3982     }
3983 
3984 
3985     @Test(dataProvider = "shortCompareOpProvider")
3986     static void EQShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3987         short[] a = fa.apply(SPECIES.length());
3988         short[] b = fb.apply(SPECIES.length());
3989 
3990         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3991             for (int i = 0; i < a.length; i += SPECIES.length()) {
3992                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3993                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3994                 VectorMask<Short> mv = av.compare(VectorOperators.EQ, bv);
3995 
3996                 // Check results as part of computation.
3997                 for (int j = 0; j < SPECIES.length(); j++) {
3998                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3999                 }
4000             }
4001         }
4002     }
4003 
4004 
4005     @Test(dataProvider = "shortCompareOpProvider")
4006     static void eqShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4007         short[] a = fa.apply(SPECIES.length());
4008         short[] b = fb.apply(SPECIES.length());
4009 
4010         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4011             for (int i = 0; i < a.length; i += SPECIES.length()) {
4012                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4013                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4014                 VectorMask<Short> mv = av.eq(bv);
4015 
4016                 // Check results as part of computation.
4017                 for (int j = 0; j < SPECIES.length(); j++) {
4018                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4019                 }
4020             }
4021         }
4022     }
4023 
4024     @Test(dataProvider = "shortCompareOpMaskProvider")
4025     static void EQShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4026                                                 IntFunction<boolean[]> fm) {
4027         short[] a = fa.apply(SPECIES.length());
4028         short[] b = fb.apply(SPECIES.length());
4029         boolean[] mask = fm.apply(SPECIES.length());
4030 
4031         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4032 
4033         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4034             for (int i = 0; i < a.length; i += SPECIES.length()) {
4035                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4036                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4037                 VectorMask<Short> mv = av.compare(VectorOperators.EQ, bv, vmask);
4038 
4039                 // Check results as part of computation.
4040                 for (int j = 0; j < SPECIES.length(); j++) {
4041                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
4042                 }
4043             }
4044         }
4045     }
4046 
4047 
4048     @Test(dataProvider = "shortCompareOpProvider")
4049     static void NEShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4050         short[] a = fa.apply(SPECIES.length());
4051         short[] b = fb.apply(SPECIES.length());
4052 
4053         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4054             for (int i = 0; i < a.length; i += SPECIES.length()) {
4055                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4056                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4057                 VectorMask<Short> mv = av.compare(VectorOperators.NE, bv);
4058 
4059                 // Check results as part of computation.
4060                 for (int j = 0; j < SPECIES.length(); j++) {
4061                     Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
4062                 }
4063             }
4064         }
4065     }
4066 
4067     @Test(dataProvider = "shortCompareOpMaskProvider")
4068     static void NEShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4069                                                 IntFunction<boolean[]> fm) {
4070         short[] a = fa.apply(SPECIES.length());
4071         short[] b = fb.apply(SPECIES.length());
4072         boolean[] mask = fm.apply(SPECIES.length());
4073 
4074         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4075 
4076         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4077             for (int i = 0; i < a.length; i += SPECIES.length()) {
4078                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4079                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4080                 VectorMask<Short> mv = av.compare(VectorOperators.NE, bv, vmask);
4081 
4082                 // Check results as part of computation.
4083                 for (int j = 0; j < SPECIES.length(); j++) {
4084                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
4085                 }
4086             }
4087         }
4088     }
4089 
4090 
4091     @Test(dataProvider = "shortCompareOpProvider")
4092     static void LEShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4093         short[] a = fa.apply(SPECIES.length());
4094         short[] b = fb.apply(SPECIES.length());
4095 
4096         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4097             for (int i = 0; i < a.length; i += SPECIES.length()) {
4098                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4099                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4100                 VectorMask<Short> mv = av.compare(VectorOperators.LE, bv);
4101 
4102                 // Check results as part of computation.
4103                 for (int j = 0; j < SPECIES.length(); j++) {
4104                     Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
4105                 }
4106             }
4107         }
4108     }
4109 
4110     @Test(dataProvider = "shortCompareOpMaskProvider")
4111     static void LEShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4112                                                 IntFunction<boolean[]> fm) {
4113         short[] a = fa.apply(SPECIES.length());
4114         short[] b = fb.apply(SPECIES.length());
4115         boolean[] mask = fm.apply(SPECIES.length());
4116 
4117         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4118 
4119         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4120             for (int i = 0; i < a.length; i += SPECIES.length()) {
4121                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4122                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4123                 VectorMask<Short> mv = av.compare(VectorOperators.LE, bv, vmask);
4124 
4125                 // Check results as part of computation.
4126                 for (int j = 0; j < SPECIES.length(); j++) {
4127                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
4128                 }
4129             }
4130         }
4131     }
4132 
4133 
4134     @Test(dataProvider = "shortCompareOpProvider")
4135     static void GEShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4136         short[] a = fa.apply(SPECIES.length());
4137         short[] b = fb.apply(SPECIES.length());
4138 
4139         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4140             for (int i = 0; i < a.length; i += SPECIES.length()) {
4141                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4142                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4143                 VectorMask<Short> mv = av.compare(VectorOperators.GE, bv);
4144 
4145                 // Check results as part of computation.
4146                 for (int j = 0; j < SPECIES.length(); j++) {
4147                     Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
4148                 }
4149             }
4150         }
4151     }
4152 
4153     @Test(dataProvider = "shortCompareOpMaskProvider")
4154     static void GEShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4155                                                 IntFunction<boolean[]> fm) {
4156         short[] a = fa.apply(SPECIES.length());
4157         short[] b = fb.apply(SPECIES.length());
4158         boolean[] mask = fm.apply(SPECIES.length());
4159 
4160         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4161 
4162         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4163             for (int i = 0; i < a.length; i += SPECIES.length()) {
4164                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4165                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4166                 VectorMask<Short> mv = av.compare(VectorOperators.GE, bv, vmask);
4167 
4168                 // Check results as part of computation.
4169                 for (int j = 0; j < SPECIES.length(); j++) {
4170                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
4171                 }
4172             }
4173         }
4174     }
4175 
4176 
4177 
4178     @Test(dataProvider = "shortCompareOpProvider")
4179     static void UNSIGNED_LTShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4180         short[] a = fa.apply(SPECIES.length());
4181         short[] b = fb.apply(SPECIES.length());
4182 
4183         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4184             for (int i = 0; i < a.length; i += SPECIES.length()) {
4185                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4186                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4187                 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_LT, bv);
4188 
4189                 // Check results as part of computation.
4190                 for (int j = 0; j < SPECIES.length(); j++) {
4191                     Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
4192                 }
4193             }
4194         }
4195     }
4196 
4197 
4198 
4199     @Test(dataProvider = "shortCompareOpMaskProvider")
4200     static void UNSIGNED_LTShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4201                                                 IntFunction<boolean[]> fm) {
4202         short[] a = fa.apply(SPECIES.length());
4203         short[] b = fb.apply(SPECIES.length());
4204         boolean[] mask = fm.apply(SPECIES.length());
4205 
4206         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4207 
4208         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4209             for (int i = 0; i < a.length; i += SPECIES.length()) {
4210                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4211                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4212                 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_LT, bv, vmask);
4213 
4214                 // Check results as part of computation.
4215                 for (int j = 0; j < SPECIES.length(); j++) {
4216                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
4217                 }
4218             }
4219         }
4220     }
4221 
4222 
4223 
4224 
4225     @Test(dataProvider = "shortCompareOpProvider")
4226     static void UNSIGNED_GTShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4227         short[] a = fa.apply(SPECIES.length());
4228         short[] b = fb.apply(SPECIES.length());
4229 
4230         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4231             for (int i = 0; i < a.length; i += SPECIES.length()) {
4232                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4233                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4234                 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_GT, bv);
4235 
4236                 // Check results as part of computation.
4237                 for (int j = 0; j < SPECIES.length(); j++) {
4238                     Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
4239                 }
4240             }
4241         }
4242     }
4243 
4244 
4245 
4246     @Test(dataProvider = "shortCompareOpMaskProvider")
4247     static void UNSIGNED_GTShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4248                                                 IntFunction<boolean[]> fm) {
4249         short[] a = fa.apply(SPECIES.length());
4250         short[] b = fb.apply(SPECIES.length());
4251         boolean[] mask = fm.apply(SPECIES.length());
4252 
4253         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4254 
4255         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4256             for (int i = 0; i < a.length; i += SPECIES.length()) {
4257                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4258                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4259                 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_GT, bv, vmask);
4260 
4261                 // Check results as part of computation.
4262                 for (int j = 0; j < SPECIES.length(); j++) {
4263                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
4264                 }
4265             }
4266         }
4267     }
4268 
4269 
4270 
4271 
4272     @Test(dataProvider = "shortCompareOpProvider")
4273     static void UNSIGNED_LEShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4274         short[] a = fa.apply(SPECIES.length());
4275         short[] b = fb.apply(SPECIES.length());
4276 
4277         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4278             for (int i = 0; i < a.length; i += SPECIES.length()) {
4279                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4280                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4281                 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_LE, bv);
4282 
4283                 // Check results as part of computation.
4284                 for (int j = 0; j < SPECIES.length(); j++) {
4285                     Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
4286                 }
4287             }
4288         }
4289     }
4290 
4291 
4292 
4293     @Test(dataProvider = "shortCompareOpMaskProvider")
4294     static void UNSIGNED_LEShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4295                                                 IntFunction<boolean[]> fm) {
4296         short[] a = fa.apply(SPECIES.length());
4297         short[] b = fb.apply(SPECIES.length());
4298         boolean[] mask = fm.apply(SPECIES.length());
4299 
4300         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4301 
4302         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4303             for (int i = 0; i < a.length; i += SPECIES.length()) {
4304                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4305                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4306                 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_LE, bv, vmask);
4307 
4308                 // Check results as part of computation.
4309                 for (int j = 0; j < SPECIES.length(); j++) {
4310                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j]));
4311                 }
4312             }
4313         }
4314     }
4315 
4316 
4317 
4318 
4319     @Test(dataProvider = "shortCompareOpProvider")
4320     static void UNSIGNED_GEShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4321         short[] a = fa.apply(SPECIES.length());
4322         short[] b = fb.apply(SPECIES.length());
4323 
4324         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4325             for (int i = 0; i < a.length; i += SPECIES.length()) {
4326                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4327                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4328                 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_GE, bv);
4329 
4330                 // Check results as part of computation.
4331                 for (int j = 0; j < SPECIES.length(); j++) {
4332                     Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
4333                 }
4334             }
4335         }
4336     }
4337 
4338 
4339 
4340     @Test(dataProvider = "shortCompareOpMaskProvider")
4341     static void UNSIGNED_GEShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4342                                                 IntFunction<boolean[]> fm) {
4343         short[] a = fa.apply(SPECIES.length());
4344         short[] b = fb.apply(SPECIES.length());
4345         boolean[] mask = fm.apply(SPECIES.length());
4346 
4347         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4348 
4349         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4350             for (int i = 0; i < a.length; i += SPECIES.length()) {
4351                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4352                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4353                 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_GE, bv, vmask);
4354 
4355                 // Check results as part of computation.
4356                 for (int j = 0; j < SPECIES.length(); j++) {
4357                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
4358                 }
4359             }
4360         }
4361     }
4362 
4363 
4364 
4365     @Test(dataProvider = "shortCompareOpProvider")
4366     static void LTShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4367         short[] a = fa.apply(SPECIES.length());
4368         short[] b = fb.apply(SPECIES.length());
4369 
4370         for (int i = 0; i < a.length; i += SPECIES.length()) {
4371             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4372             VectorMask<Short> mv = av.compare(VectorOperators.LT, b[i]);
4373 
4374             // Check results as part of computation.
4375             for (int j = 0; j < SPECIES.length(); j++) {
4376                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
4377             }
4378         }
4379     }
4380 
4381 
4382     @Test(dataProvider = "shortCompareOpMaskProvider")
4383     static void LTShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa,
4384                                 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
4385         short[] a = fa.apply(SPECIES.length());
4386         short[] b = fb.apply(SPECIES.length());
4387         boolean[] mask = fm.apply(SPECIES.length());
4388 
4389         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4390 
4391         for (int i = 0; i < a.length; i += SPECIES.length()) {
4392             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4393             VectorMask<Short> mv = av.compare(VectorOperators.LT, b[i], vmask);
4394 
4395             // Check results as part of computation.
4396             for (int j = 0; j < SPECIES.length(); j++) {
4397                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
4398             }
4399         }
4400     }
4401 
4402     @Test(dataProvider = "shortCompareOpProvider")
4403     static void LTShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4404         short[] a = fa.apply(SPECIES.length());
4405         short[] b = fb.apply(SPECIES.length());
4406 
4407         for (int i = 0; i < a.length; i += SPECIES.length()) {
4408             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4409             VectorMask<Short> mv = av.compare(VectorOperators.LT, (long)b[i]);
4410 
4411             // Check results as part of computation.
4412             for (int j = 0; j < SPECIES.length(); j++) {
4413                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (short)((long)b[i]));
4414             }
4415         }
4416     }
4417 
4418 
4419     @Test(dataProvider = "shortCompareOpMaskProvider")
4420     static void LTShortMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<short[]> fa,
4421                                 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
4422         short[] a = fa.apply(SPECIES.length());
4423         short[] b = fb.apply(SPECIES.length());
4424         boolean[] mask = fm.apply(SPECIES.length());
4425 
4426         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4427 
4428         for (int i = 0; i < a.length; i += SPECIES.length()) {
4429             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4430             VectorMask<Short> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
4431 
4432             // Check results as part of computation.
4433             for (int j = 0; j < SPECIES.length(); j++) {
4434                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (short)((long)b[i])));
4435             }
4436         }
4437     }
4438 
4439     @Test(dataProvider = "shortCompareOpProvider")
4440     static void EQShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4441         short[] a = fa.apply(SPECIES.length());
4442         short[] b = fb.apply(SPECIES.length());
4443 
4444         for (int i = 0; i < a.length; i += SPECIES.length()) {
4445             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4446             VectorMask<Short> mv = av.compare(VectorOperators.EQ, b[i]);
4447 
4448             // Check results as part of computation.
4449             for (int j = 0; j < SPECIES.length(); j++) {
4450                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
4451             }
4452         }
4453     }
4454 
4455 
4456     @Test(dataProvider = "shortCompareOpMaskProvider")
4457     static void EQShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa,
4458                                 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
4459         short[] a = fa.apply(SPECIES.length());
4460         short[] b = fb.apply(SPECIES.length());
4461         boolean[] mask = fm.apply(SPECIES.length());
4462 
4463         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4464 
4465         for (int i = 0; i < a.length; i += SPECIES.length()) {
4466             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4467             VectorMask<Short> mv = av.compare(VectorOperators.EQ, b[i], vmask);
4468 
4469             // Check results as part of computation.
4470             for (int j = 0; j < SPECIES.length(); j++) {
4471                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
4472             }
4473         }
4474     }
4475 
4476     @Test(dataProvider = "shortCompareOpProvider")
4477     static void EQShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4478         short[] a = fa.apply(SPECIES.length());
4479         short[] b = fb.apply(SPECIES.length());
4480 
4481         for (int i = 0; i < a.length; i += SPECIES.length()) {
4482             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4483             VectorMask<Short> mv = av.compare(VectorOperators.EQ, (long)b[i]);
4484 
4485             // Check results as part of computation.
4486             for (int j = 0; j < SPECIES.length(); j++) {
4487                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (short)((long)b[i]));
4488             }
4489         }
4490     }
4491 
4492 
4493     @Test(dataProvider = "shortCompareOpMaskProvider")
4494     static void EQShortMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<short[]> fa,
4495                                 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
4496         short[] a = fa.apply(SPECIES.length());
4497         short[] b = fb.apply(SPECIES.length());
4498         boolean[] mask = fm.apply(SPECIES.length());
4499 
4500         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4501 
4502         for (int i = 0; i < a.length; i += SPECIES.length()) {
4503             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4504             VectorMask<Short> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
4505 
4506             // Check results as part of computation.
4507             for (int j = 0; j < SPECIES.length(); j++) {
4508                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (short)((long)b[i])));
4509             }
4510         }
4511     }
4512 
4513     static short blend(short a, short b, boolean mask) {
4514         return mask ? b : a;
4515     }
4516 
4517     @Test(dataProvider = "shortBinaryOpMaskProvider")
4518     static void blendShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb,
4519                                           IntFunction<boolean[]> fm) {
4520         short[] a = fa.apply(SPECIES.length());
4521         short[] b = fb.apply(SPECIES.length());
4522         short[] r = fr.apply(SPECIES.length());
4523         boolean[] mask = fm.apply(SPECIES.length());
4524         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4525 
4526         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4527             for (int i = 0; i < a.length; i += SPECIES.length()) {
4528                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4529                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4530                 av.blend(bv, vmask).intoArray(r, i);
4531             }
4532         }
4533 
4534         assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::blend);
4535     }
4536 
4537     @Test(dataProvider = "shortUnaryOpShuffleProvider")
4538     static void RearrangeShortMaxVectorTests(IntFunction<short[]> fa,
4539                                            BiFunction<Integer,Integer,int[]> fs) {
4540         short[] a = fa.apply(SPECIES.length());
4541         int[] order = fs.apply(a.length, SPECIES.length());
4542         short[] r = fr.apply(SPECIES.length());
4543 
4544         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4545             for (int i = 0; i < a.length; i += SPECIES.length()) {
4546                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4547                 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
4548             }
4549         }
4550 
4551         assertRearrangeArraysEquals(r, a, order, SPECIES.length());
4552     }
4553 
4554     @Test(dataProvider = "shortUnaryOpShuffleMaskProvider")
4555     static void RearrangeShortMaxVectorTestsMaskedSmokeTest(IntFunction<short[]> fa,
4556                                                           BiFunction<Integer,Integer,int[]> fs,
4557                                                           IntFunction<boolean[]> fm) {
4558         short[] a = fa.apply(SPECIES.length());
4559         int[] order = fs.apply(a.length, SPECIES.length());
4560         short[] r = fr.apply(SPECIES.length());
4561         boolean[] mask = fm.apply(SPECIES.length());
4562         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4563 
4564         for (int i = 0; i < a.length; i += SPECIES.length()) {
4565             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4566             av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
4567         }
4568 
4569         assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
4570     }





































4571     @Test(dataProvider = "shortUnaryOpProvider")
4572     static void getShortMaxVectorTests(IntFunction<short[]> fa) {
4573         short[] a = fa.apply(SPECIES.length());
4574         short[] r = fr.apply(SPECIES.length());
4575 
4576         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4577             for (int i = 0; i < a.length; i += SPECIES.length()) {
4578                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4579                 int num_lanes = SPECIES.length();
4580                 // Manually unroll because full unroll happens after intrinsification.
4581                 // Unroll is needed because get intrinsic requires for index to be a known constant.
4582                 if (num_lanes == 1) {
4583                     r[i]=av.lane(0);
4584                 } else if (num_lanes == 2) {
4585                     r[i]=av.lane(0);
4586                     r[i+1]=av.lane(1);
4587                 } else if (num_lanes == 4) {
4588                     r[i]=av.lane(0);
4589                     r[i+1]=av.lane(1);
4590                     r[i+2]=av.lane(2);
4591                     r[i+3]=av.lane(3);
4592                 } else if (num_lanes == 8) {
4593                     r[i]=av.lane(0);
4594                     r[i+1]=av.lane(1);
4595                     r[i+2]=av.lane(2);
4596                     r[i+3]=av.lane(3);
4597                     r[i+4]=av.lane(4);
4598                     r[i+5]=av.lane(5);
4599                     r[i+6]=av.lane(6);
4600                     r[i+7]=av.lane(7);
4601                 } else if (num_lanes == 16) {
4602                     r[i]=av.lane(0);
4603                     r[i+1]=av.lane(1);
4604                     r[i+2]=av.lane(2);
4605                     r[i+3]=av.lane(3);
4606                     r[i+4]=av.lane(4);
4607                     r[i+5]=av.lane(5);
4608                     r[i+6]=av.lane(6);
4609                     r[i+7]=av.lane(7);
4610                     r[i+8]=av.lane(8);
4611                     r[i+9]=av.lane(9);
4612                     r[i+10]=av.lane(10);
4613                     r[i+11]=av.lane(11);
4614                     r[i+12]=av.lane(12);
4615                     r[i+13]=av.lane(13);
4616                     r[i+14]=av.lane(14);
4617                     r[i+15]=av.lane(15);
4618                 } else if (num_lanes == 32) {
4619                     r[i]=av.lane(0);
4620                     r[i+1]=av.lane(1);
4621                     r[i+2]=av.lane(2);
4622                     r[i+3]=av.lane(3);
4623                     r[i+4]=av.lane(4);
4624                     r[i+5]=av.lane(5);
4625                     r[i+6]=av.lane(6);
4626                     r[i+7]=av.lane(7);
4627                     r[i+8]=av.lane(8);
4628                     r[i+9]=av.lane(9);
4629                     r[i+10]=av.lane(10);
4630                     r[i+11]=av.lane(11);
4631                     r[i+12]=av.lane(12);
4632                     r[i+13]=av.lane(13);
4633                     r[i+14]=av.lane(14);
4634                     r[i+15]=av.lane(15);
4635                     r[i+16]=av.lane(16);
4636                     r[i+17]=av.lane(17);
4637                     r[i+18]=av.lane(18);
4638                     r[i+19]=av.lane(19);
4639                     r[i+20]=av.lane(20);
4640                     r[i+21]=av.lane(21);
4641                     r[i+22]=av.lane(22);
4642                     r[i+23]=av.lane(23);
4643                     r[i+24]=av.lane(24);
4644                     r[i+25]=av.lane(25);
4645                     r[i+26]=av.lane(26);
4646                     r[i+27]=av.lane(27);
4647                     r[i+28]=av.lane(28);
4648                     r[i+29]=av.lane(29);
4649                     r[i+30]=av.lane(30);
4650                     r[i+31]=av.lane(31);
4651                 } else if (num_lanes == 64) {
4652                     r[i]=av.lane(0);
4653                     r[i+1]=av.lane(1);
4654                     r[i+2]=av.lane(2);
4655                     r[i+3]=av.lane(3);
4656                     r[i+4]=av.lane(4);
4657                     r[i+5]=av.lane(5);
4658                     r[i+6]=av.lane(6);
4659                     r[i+7]=av.lane(7);
4660                     r[i+8]=av.lane(8);
4661                     r[i+9]=av.lane(9);
4662                     r[i+10]=av.lane(10);
4663                     r[i+11]=av.lane(11);
4664                     r[i+12]=av.lane(12);
4665                     r[i+13]=av.lane(13);
4666                     r[i+14]=av.lane(14);
4667                     r[i+15]=av.lane(15);
4668                     r[i+16]=av.lane(16);
4669                     r[i+17]=av.lane(17);
4670                     r[i+18]=av.lane(18);
4671                     r[i+19]=av.lane(19);
4672                     r[i+20]=av.lane(20);
4673                     r[i+21]=av.lane(21);
4674                     r[i+22]=av.lane(22);
4675                     r[i+23]=av.lane(23);
4676                     r[i+24]=av.lane(24);
4677                     r[i+25]=av.lane(25);
4678                     r[i+26]=av.lane(26);
4679                     r[i+27]=av.lane(27);
4680                     r[i+28]=av.lane(28);
4681                     r[i+29]=av.lane(29);
4682                     r[i+30]=av.lane(30);
4683                     r[i+31]=av.lane(31);
4684                     r[i+32]=av.lane(32);
4685                     r[i+33]=av.lane(33);
4686                     r[i+34]=av.lane(34);
4687                     r[i+35]=av.lane(35);
4688                     r[i+36]=av.lane(36);
4689                     r[i+37]=av.lane(37);
4690                     r[i+38]=av.lane(38);
4691                     r[i+39]=av.lane(39);
4692                     r[i+40]=av.lane(40);
4693                     r[i+41]=av.lane(41);
4694                     r[i+42]=av.lane(42);
4695                     r[i+43]=av.lane(43);
4696                     r[i+44]=av.lane(44);
4697                     r[i+45]=av.lane(45);
4698                     r[i+46]=av.lane(46);
4699                     r[i+47]=av.lane(47);
4700                     r[i+48]=av.lane(48);
4701                     r[i+49]=av.lane(49);
4702                     r[i+50]=av.lane(50);
4703                     r[i+51]=av.lane(51);
4704                     r[i+52]=av.lane(52);
4705                     r[i+53]=av.lane(53);
4706                     r[i+54]=av.lane(54);
4707                     r[i+55]=av.lane(55);
4708                     r[i+56]=av.lane(56);
4709                     r[i+57]=av.lane(57);
4710                     r[i+58]=av.lane(58);
4711                     r[i+59]=av.lane(59);
4712                     r[i+60]=av.lane(60);
4713                     r[i+61]=av.lane(61);
4714                     r[i+62]=av.lane(62);
4715                     r[i+63]=av.lane(63);
4716                 } else {
4717                     for (int j = 0; j < SPECIES.length(); j++) {
4718                         r[i+j]=av.lane(j);
4719                     }
4720                 }
4721             }
4722         }
4723 
4724         assertArraysEquals(r, a, ShortMaxVectorTests::get);
4725     }
4726 
4727     @Test(dataProvider = "shortUnaryOpProvider")
4728     static void BroadcastShortMaxVectorTests(IntFunction<short[]> fa) {
4729         short[] a = fa.apply(SPECIES.length());
4730         short[] r = new short[a.length];
4731 
4732         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4733             for (int i = 0; i < a.length; i += SPECIES.length()) {
4734                 ShortVector.broadcast(SPECIES, a[i]).intoArray(r, i);
4735             }
4736         }
4737 
4738         assertBroadcastArraysEquals(r, a);
4739     }
4740 
4741 
4742 
4743 
4744 
4745     @Test(dataProvider = "shortUnaryOpProvider")
4746     static void ZeroShortMaxVectorTests(IntFunction<short[]> fa) {
4747         short[] a = fa.apply(SPECIES.length());
4748         short[] r = new short[a.length];
4749 
4750         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4751             for (int i = 0; i < a.length; i += SPECIES.length()) {
4752                 ShortVector.zero(SPECIES).intoArray(a, i);
4753             }
4754         }
4755 
4756         Assert.assertEquals(a, r);
4757     }
4758 
4759 
4760 
4761 
4762     static short[] sliceUnary(short[] a, int origin, int idx) {
4763         short[] res = new short[SPECIES.length()];
4764         for (int i = 0; i < SPECIES.length(); i++){
4765             if(i+origin < SPECIES.length())
4766                 res[i] = a[idx+i+origin];
4767             else
4768                 res[i] = (short)0;
4769         }
4770         return res;
4771     }
4772 
4773     @Test(dataProvider = "shortUnaryOpProvider")
4774     static void sliceUnaryShortMaxVectorTests(IntFunction<short[]> fa) {
4775         short[] a = fa.apply(SPECIES.length());
4776         short[] r = new short[a.length];
4777         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4778         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4779             for (int i = 0; i < a.length; i += SPECIES.length()) {
4780                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4781                 av.slice(origin).intoArray(r, i);
4782             }
4783         }
4784 
4785         assertArraysEquals(r, a, origin, ShortMaxVectorTests::sliceUnary);
4786     }

4787     static short[] sliceBinary(short[] a, short[] b, int origin, int idx) {
4788         short[] res = new short[SPECIES.length()];
4789         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4790             if(i+origin < SPECIES.length())
4791                 res[i] = a[idx+i+origin];
4792             else {
4793                 res[i] = b[idx+j];
4794                 j++;
4795             }
4796         }
4797         return res;
4798     }
4799 
4800     @Test(dataProvider = "shortBinaryOpProvider")
4801     static void sliceBinaryShortMaxVectorTestsBinary(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4802         short[] a = fa.apply(SPECIES.length());
4803         short[] b = fb.apply(SPECIES.length());
4804         short[] r = new short[a.length];
4805         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4806         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4807             for (int i = 0; i < a.length; i += SPECIES.length()) {
4808                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4809                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4810                 av.slice(origin, bv).intoArray(r, i);
4811             }
4812         }
4813 
4814         assertArraysEquals(r, a, b, origin, ShortMaxVectorTests::sliceBinary);
4815     }

4816     static short[] slice(short[] a, short[] b, int origin, boolean[] mask, int idx) {
4817         short[] res = new short[SPECIES.length()];
4818         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4819             if(i+origin < SPECIES.length())
4820                 res[i] = mask[i] ? a[idx+i+origin] : (short)0;
4821             else {
4822                 res[i] = mask[i] ? b[idx+j] : (short)0;
4823                 j++;
4824             }
4825         }
4826         return res;
4827     }
4828 
4829     @Test(dataProvider = "shortBinaryOpMaskProvider")
4830     static void sliceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4831     IntFunction<boolean[]> fm) {
4832         short[] a = fa.apply(SPECIES.length());
4833         short[] b = fb.apply(SPECIES.length());
4834         boolean[] mask = fm.apply(SPECIES.length());
4835         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4836 
4837         short[] r = new short[a.length];
4838         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4839         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4840             for (int i = 0; i < a.length; i += SPECIES.length()) {
4841                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4842                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4843                 av.slice(origin, bv, vmask).intoArray(r, i);
4844             }
4845         }
4846 
4847         assertArraysEquals(r, a, b, origin, mask, ShortMaxVectorTests::slice);
4848     }

4849     static short[] unsliceUnary(short[] a, int origin, int idx) {
4850         short[] res = new short[SPECIES.length()];
4851         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4852             if(i < origin)
4853                 res[i] = (short)0;
4854             else {
4855                 res[i] = a[idx+j];
4856                 j++;
4857             }
4858         }
4859         return res;
4860     }
4861 
4862     @Test(dataProvider = "shortUnaryOpProvider")
4863     static void unsliceUnaryShortMaxVectorTests(IntFunction<short[]> fa) {
4864         short[] a = fa.apply(SPECIES.length());
4865         short[] r = new short[a.length];
4866         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4867         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4868             for (int i = 0; i < a.length; i += SPECIES.length()) {
4869                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4870                 av.unslice(origin).intoArray(r, i);
4871             }
4872         }
4873 
4874         assertArraysEquals(r, a, origin, ShortMaxVectorTests::unsliceUnary);
4875     }

4876     static short[] unsliceBinary(short[] a, short[] b, int origin, int part, int idx) {
4877         short[] res = new short[SPECIES.length()];
4878         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4879             if (part == 0) {
4880                 if (i < origin)
4881                     res[i] = b[idx+i];
4882                 else {
4883                     res[i] = a[idx+j];
4884                     j++;
4885                 }
4886             } else if (part == 1) {
4887                 if (i < origin)
4888                     res[i] = a[idx+SPECIES.length()-origin+i];
4889                 else {
4890                     res[i] = b[idx+origin+j];
4891                     j++;
4892                 }
4893             }
4894         }
4895         return res;
4896     }
4897 
4898     @Test(dataProvider = "shortBinaryOpProvider")
4899     static void unsliceBinaryShortMaxVectorTestsBinary(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4900         short[] a = fa.apply(SPECIES.length());
4901         short[] b = fb.apply(SPECIES.length());
4902         short[] r = new short[a.length];
4903         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4904         int part = (new java.util.Random()).nextInt(2);
4905         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4906             for (int i = 0; i < a.length; i += SPECIES.length()) {
4907                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4908                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4909                 av.unslice(origin, bv, part).intoArray(r, i);
4910             }
4911         }
4912 
4913         assertArraysEquals(r, a, b, origin, part, ShortMaxVectorTests::unsliceBinary);
4914     }

4915     static short[] unslice(short[] a, short[] b, int origin, int part, boolean[] mask, int idx) {
4916         short[] res = new short[SPECIES.length()];
4917         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4918             if(i+origin < SPECIES.length())
4919                 res[i] = b[idx+i+origin];
4920             else {
4921                 res[i] = b[idx+j];
4922                 j++;
4923             }
4924         }
4925         for (int i = 0; i < SPECIES.length(); i++){
4926             res[i] = mask[i] ? a[idx+i] : res[i];
4927         }
4928         short[] res1 = new short[SPECIES.length()];
4929         if (part == 0) {
4930             for (int i = 0, j = 0; i < SPECIES.length(); i++){
4931                 if (i < origin)
4932                     res1[i] = b[idx+i];
4933                 else {
4934                    res1[i] = res[j];
4935                    j++;
4936                 }
4937             }
4938         } else if (part == 1) {
4939             for (int i = 0, j = 0; i < SPECIES.length(); i++){
4940                 if (i < origin)
4941                     res1[i] = res[SPECIES.length()-origin+i];
4942                 else {
4943                     res1[i] = b[idx+origin+j];
4944                     j++;
4945                 }
4946             }
4947         }
4948         return res1;
4949     }
4950 
4951     @Test(dataProvider = "shortBinaryOpMaskProvider")
4952     static void unsliceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4953     IntFunction<boolean[]> fm) {
4954         short[] a = fa.apply(SPECIES.length());
4955         short[] b = fb.apply(SPECIES.length());
4956         boolean[] mask = fm.apply(SPECIES.length());
4957         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4958         short[] r = new short[a.length];
4959         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4960         int part = (new java.util.Random()).nextInt(2);
4961         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4962             for (int i = 0; i < a.length; i += SPECIES.length()) {
4963                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4964                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4965                 av.unslice(origin, bv, part, vmask).intoArray(r, i);
4966             }
4967         }
4968 
4969         assertArraysEquals(r, a, b, origin, part, mask, ShortMaxVectorTests::unslice);
4970     }
4971 
4972 
4973 
4974 
4975 
4976 
4977 
4978 
4979 
4980 
4981 
4982 
4983 
4984 
4985 
4986 
4987 
4988 
4989 
4990 
4991 
4992 
4993 
4994     static short BITWISE_BLEND(short a, short b, short c) {
4995         return (short)((a&~(c))|(b&c));
4996     }

4997     static short bitwiseBlend(short a, short b, short c) {
4998         return (short)((a&~(c))|(b&c));
4999     }
5000 
5001 
5002     @Test(dataProvider = "shortTernaryOpProvider")
5003     static void BITWISE_BLENDShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5004         short[] a = fa.apply(SPECIES.length());
5005         short[] b = fb.apply(SPECIES.length());
5006         short[] c = fc.apply(SPECIES.length());
5007         short[] r = fr.apply(SPECIES.length());
5008 
5009         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5010             for (int i = 0; i < a.length; i += SPECIES.length()) {
5011                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5012                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5013                 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5014                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
5015             }
5016         }
5017 
5018         assertArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND);
5019     }

5020     @Test(dataProvider = "shortTernaryOpProvider")
5021     static void bitwiseBlendShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5022         short[] a = fa.apply(SPECIES.length());
5023         short[] b = fb.apply(SPECIES.length());
5024         short[] c = fc.apply(SPECIES.length());
5025         short[] r = fr.apply(SPECIES.length());
5026 
5027         for (int i = 0; i < a.length; i += SPECIES.length()) {
5028             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5029             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5030             ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5031             av.bitwiseBlend(bv, cv).intoArray(r, i);
5032         }
5033 
5034         assertArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend);
5035     }
5036 
5037 
5038     @Test(dataProvider = "shortTernaryOpMaskProvider")
5039     static void BITWISE_BLENDShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
5040                                           IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5041         short[] a = fa.apply(SPECIES.length());
5042         short[] b = fb.apply(SPECIES.length());
5043         short[] c = fc.apply(SPECIES.length());
5044         short[] r = fr.apply(SPECIES.length());
5045         boolean[] mask = fm.apply(SPECIES.length());
5046         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5047 
5048         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5049             for (int i = 0; i < a.length; i += SPECIES.length()) {
5050                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5051                 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5052                 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5053                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
5054             }
5055         }
5056 
5057         assertArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND);
5058     }
5059 
5060 
5061 
5062 
5063     @Test(dataProvider = "shortTernaryOpProvider")
5064     static void BITWISE_BLENDShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5065         short[] a = fa.apply(SPECIES.length());
5066         short[] b = fb.apply(SPECIES.length());
5067         short[] c = fc.apply(SPECIES.length());
5068         short[] r = fr.apply(SPECIES.length());
5069 
5070         for (int i = 0; i < a.length; i += SPECIES.length()) {
5071             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5072             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5073             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
5074         }
5075         assertBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND);
5076     }
5077 
5078     @Test(dataProvider = "shortTernaryOpProvider")
5079     static void BITWISE_BLENDShortMaxVectorTestsAltBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5080         short[] a = fa.apply(SPECIES.length());
5081         short[] b = fb.apply(SPECIES.length());
5082         short[] c = fc.apply(SPECIES.length());
5083         short[] r = fr.apply(SPECIES.length());
5084 
5085         for (int i = 0; i < a.length; i += SPECIES.length()) {
5086             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5087             ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5088             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
5089         }
5090         assertAltBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND);
5091     }

5092     @Test(dataProvider = "shortTernaryOpProvider")
5093     static void bitwiseBlendShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5094         short[] a = fa.apply(SPECIES.length());
5095         short[] b = fb.apply(SPECIES.length());
5096         short[] c = fc.apply(SPECIES.length());
5097         short[] r = fr.apply(SPECIES.length());
5098 
5099         for (int i = 0; i < a.length; i += SPECIES.length()) {
5100             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5101             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5102             av.bitwiseBlend(bv, c[i]).intoArray(r, i);
5103         }
5104         assertBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend);
5105     }
5106 
5107     @Test(dataProvider = "shortTernaryOpProvider")
5108     static void bitwiseBlendShortMaxVectorTestsAltBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5109         short[] a = fa.apply(SPECIES.length());
5110         short[] b = fb.apply(SPECIES.length());
5111         short[] c = fc.apply(SPECIES.length());
5112         short[] r = fr.apply(SPECIES.length());
5113 
5114         for (int i = 0; i < a.length; i += SPECIES.length()) {
5115             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5116             ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5117             av.bitwiseBlend(b[i], cv).intoArray(r, i);
5118         }
5119         assertAltBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend);
5120     }
5121 
5122 
5123     @Test(dataProvider = "shortTernaryOpMaskProvider")
5124     static void BITWISE_BLENDShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5125                                           IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5126         short[] a = fa.apply(SPECIES.length());
5127         short[] b = fb.apply(SPECIES.length());
5128         short[] c = fc.apply(SPECIES.length());
5129         short[] r = fr.apply(SPECIES.length());
5130         boolean[] mask = fm.apply(SPECIES.length());
5131         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5132 
5133         for (int i = 0; i < a.length; i += SPECIES.length()) {
5134             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5135             ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5136             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
5137         }
5138 
5139         assertBroadcastArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND);
5140     }
5141 
5142     @Test(dataProvider = "shortTernaryOpMaskProvider")
5143     static void BITWISE_BLENDShortMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5144                                           IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5145         short[] a = fa.apply(SPECIES.length());
5146         short[] b = fb.apply(SPECIES.length());
5147         short[] c = fc.apply(SPECIES.length());
5148         short[] r = fr.apply(SPECIES.length());
5149         boolean[] mask = fm.apply(SPECIES.length());
5150         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5151 
5152         for (int i = 0; i < a.length; i += SPECIES.length()) {
5153             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5154             ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5155             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
5156         }
5157 
5158         assertAltBroadcastArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND);
5159     }
5160 
5161 
5162 
5163 
5164     @Test(dataProvider = "shortTernaryOpProvider")
5165     static void BITWISE_BLENDShortMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5166         short[] a = fa.apply(SPECIES.length());
5167         short[] b = fb.apply(SPECIES.length());
5168         short[] c = fc.apply(SPECIES.length());
5169         short[] r = fr.apply(SPECIES.length());
5170 
5171         for (int i = 0; i < a.length; i += SPECIES.length()) {
5172             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5173             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
5174         }
5175 
5176         assertDoubleBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND);
5177     }

5178     @Test(dataProvider = "shortTernaryOpProvider")
5179     static void bitwiseBlendShortMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5180         short[] a = fa.apply(SPECIES.length());
5181         short[] b = fb.apply(SPECIES.length());
5182         short[] c = fc.apply(SPECIES.length());
5183         short[] r = fr.apply(SPECIES.length());
5184 
5185         for (int i = 0; i < a.length; i += SPECIES.length()) {
5186             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5187             av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
5188         }
5189 
5190         assertDoubleBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend);
5191     }
5192 
5193 
5194     @Test(dataProvider = "shortTernaryOpMaskProvider")
5195     static void BITWISE_BLENDShortMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5196                                           IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5197         short[] a = fa.apply(SPECIES.length());
5198         short[] b = fb.apply(SPECIES.length());
5199         short[] c = fc.apply(SPECIES.length());
5200         short[] r = fr.apply(SPECIES.length());
5201         boolean[] mask = fm.apply(SPECIES.length());
5202         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5203 
5204         for (int i = 0; i < a.length; i += SPECIES.length()) {
5205             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5206             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
5207         }
5208 
5209         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND);
5210     }
5211 
5212 
5213     static short NEG(short a) {
5214         return (short)(-((short)a));
5215     }
5216 
5217     static short neg(short a) {
5218         return (short)(-((short)a));
5219     }
5220 
5221     @Test(dataProvider = "shortUnaryOpProvider")
5222     static void NEGShortMaxVectorTests(IntFunction<short[]> fa) {
5223         short[] a = fa.apply(SPECIES.length());
5224         short[] r = fr.apply(SPECIES.length());
5225 
5226         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5227             for (int i = 0; i < a.length; i += SPECIES.length()) {
5228                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5229                 av.lanewise(VectorOperators.NEG).intoArray(r, i);
5230             }
5231         }
5232 
5233         assertArraysEquals(r, a, ShortMaxVectorTests::NEG);
5234     }
5235 
5236     @Test(dataProvider = "shortUnaryOpProvider")
5237     static void negShortMaxVectorTests(IntFunction<short[]> fa) {
5238         short[] a = fa.apply(SPECIES.length());
5239         short[] r = fr.apply(SPECIES.length());
5240 
5241         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5242             for (int i = 0; i < a.length; i += SPECIES.length()) {
5243                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5244                 av.neg().intoArray(r, i);
5245             }
5246         }
5247 
5248         assertArraysEquals(r, a, ShortMaxVectorTests::neg);
5249     }
5250 
5251     @Test(dataProvider = "shortUnaryOpMaskProvider")
5252     static void NEGMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5253                                                 IntFunction<boolean[]> fm) {
5254         short[] a = fa.apply(SPECIES.length());
5255         short[] r = fr.apply(SPECIES.length());
5256         boolean[] mask = fm.apply(SPECIES.length());
5257         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5258 
5259         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5260             for (int i = 0; i < a.length; i += SPECIES.length()) {
5261                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5262                 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
5263             }
5264         }
5265 
5266         assertArraysEquals(r, a, mask, ShortMaxVectorTests::NEG);
5267     }
5268 
5269     static short ABS(short a) {
5270         return (short)(Math.abs((short)a));
5271     }
5272 
5273     static short abs(short a) {
5274         return (short)(Math.abs((short)a));
5275     }
5276 
5277     @Test(dataProvider = "shortUnaryOpProvider")
5278     static void ABSShortMaxVectorTests(IntFunction<short[]> fa) {
5279         short[] a = fa.apply(SPECIES.length());
5280         short[] r = fr.apply(SPECIES.length());
5281 
5282         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5283             for (int i = 0; i < a.length; i += SPECIES.length()) {
5284                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5285                 av.lanewise(VectorOperators.ABS).intoArray(r, i);
5286             }
5287         }
5288 
5289         assertArraysEquals(r, a, ShortMaxVectorTests::ABS);
5290     }
5291 
5292     @Test(dataProvider = "shortUnaryOpProvider")
5293     static void absShortMaxVectorTests(IntFunction<short[]> fa) {
5294         short[] a = fa.apply(SPECIES.length());
5295         short[] r = fr.apply(SPECIES.length());
5296 
5297         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5298             for (int i = 0; i < a.length; i += SPECIES.length()) {
5299                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5300                 av.abs().intoArray(r, i);
5301             }
5302         }
5303 
5304         assertArraysEquals(r, a, ShortMaxVectorTests::abs);
5305     }
5306 
5307     @Test(dataProvider = "shortUnaryOpMaskProvider")
5308     static void ABSMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5309                                                 IntFunction<boolean[]> fm) {
5310         short[] a = fa.apply(SPECIES.length());
5311         short[] r = fr.apply(SPECIES.length());
5312         boolean[] mask = fm.apply(SPECIES.length());
5313         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5314 
5315         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5316             for (int i = 0; i < a.length; i += SPECIES.length()) {
5317                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5318                 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
5319             }
5320         }
5321 
5322         assertArraysEquals(r, a, mask, ShortMaxVectorTests::ABS);
5323     }
5324 
5325 
5326     static short NOT(short a) {
5327         return (short)(~((short)a));
5328     }
5329 
5330     static short not(short a) {
5331         return (short)(~((short)a));
5332     }
5333 
5334 
5335 
5336     @Test(dataProvider = "shortUnaryOpProvider")
5337     static void NOTShortMaxVectorTests(IntFunction<short[]> fa) {
5338         short[] a = fa.apply(SPECIES.length());
5339         short[] r = fr.apply(SPECIES.length());
5340 
5341         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5342             for (int i = 0; i < a.length; i += SPECIES.length()) {
5343                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5344                 av.lanewise(VectorOperators.NOT).intoArray(r, i);
5345             }
5346         }
5347 
5348         assertArraysEquals(r, a, ShortMaxVectorTests::NOT);
5349     }
5350 
5351     @Test(dataProvider = "shortUnaryOpProvider")
5352     static void notShortMaxVectorTests(IntFunction<short[]> fa) {
5353         short[] a = fa.apply(SPECIES.length());
5354         short[] r = fr.apply(SPECIES.length());
5355 
5356         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5357             for (int i = 0; i < a.length; i += SPECIES.length()) {
5358                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5359                 av.not().intoArray(r, i);
5360             }
5361         }
5362 
5363         assertArraysEquals(r, a, ShortMaxVectorTests::not);
5364     }
5365 
5366 
5367 
5368     @Test(dataProvider = "shortUnaryOpMaskProvider")
5369     static void NOTMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5370                                                 IntFunction<boolean[]> fm) {
5371         short[] a = fa.apply(SPECIES.length());
5372         short[] r = fr.apply(SPECIES.length());
5373         boolean[] mask = fm.apply(SPECIES.length());
5374         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5375 
5376         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5377             for (int i = 0; i < a.length; i += SPECIES.length()) {
5378                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5379                 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
5380             }
5381         }
5382 
5383         assertArraysEquals(r, a, mask, ShortMaxVectorTests::NOT);
5384     }
5385 
5386 
5387 
5388     static short ZOMO(short a) {
5389         return (short)((a==0?0:-1));
5390     }
5391 
5392 
5393 
5394     @Test(dataProvider = "shortUnaryOpProvider")
5395     static void ZOMOShortMaxVectorTests(IntFunction<short[]> fa) {
5396         short[] a = fa.apply(SPECIES.length());
5397         short[] r = fr.apply(SPECIES.length());
5398 
5399         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5400             for (int i = 0; i < a.length; i += SPECIES.length()) {
5401                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5402                 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
5403             }
5404         }
5405 
5406         assertArraysEquals(r, a, ShortMaxVectorTests::ZOMO);
5407     }
5408 
5409 
5410 
5411     @Test(dataProvider = "shortUnaryOpMaskProvider")
5412     static void ZOMOMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5413                                                 IntFunction<boolean[]> fm) {
5414         short[] a = fa.apply(SPECIES.length());
5415         short[] r = fr.apply(SPECIES.length());
5416         boolean[] mask = fm.apply(SPECIES.length());
5417         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5418 
5419         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5420             for (int i = 0; i < a.length; i += SPECIES.length()) {
5421                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5422                 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
5423             }
5424         }
5425 
5426         assertArraysEquals(r, a, mask, ShortMaxVectorTests::ZOMO);
5427     }
5428 























































































































































5429 




5430 






5431 




















5432 
5433     @Test(dataProvider = "shortCompareOpProvider")
5434     static void ltShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5435         short[] a = fa.apply(SPECIES.length());
5436         short[] b = fb.apply(SPECIES.length());
5437 
5438         for (int i = 0; i < a.length; i += SPECIES.length()) {
5439             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5440             VectorMask<Short> mv = av.lt(b[i]);
5441 
5442             // Check results as part of computation.
5443             for (int j = 0; j < SPECIES.length(); j++) {
5444                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
5445             }
5446         }
5447     }
5448 
5449     @Test(dataProvider = "shortCompareOpProvider")
5450     static void eqShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5451         short[] a = fa.apply(SPECIES.length());
5452         short[] b = fb.apply(SPECIES.length());
5453 
5454         for (int i = 0; i < a.length; i += SPECIES.length()) {
5455             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5456             VectorMask<Short> mv = av.eq(b[i]);
5457 
5458             // Check results as part of computation.
5459             for (int j = 0; j < SPECIES.length(); j++) {
5460                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
5461             }
5462         }
5463     }
5464 
5465     @Test(dataProvider = "shortUnaryOpProvider")
5466     static void toIntArrayShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5467         short[] a = fa.apply(SPECIES.length());
5468 
5469         for (int i = 0; i < a.length; i += SPECIES.length()) {
5470             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5471             int[] r = av.toIntArray();
5472             assertArraysEquals(r, a, i);
5473         }
5474     }
5475 
5476     @Test(dataProvider = "shortUnaryOpProvider")
5477     static void toLongArrayShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5478         short[] a = fa.apply(SPECIES.length());
5479 
5480         for (int i = 0; i < a.length; i += SPECIES.length()) {
5481             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5482             long[] r = av.toLongArray();
5483             assertArraysEquals(r, a, i);
5484         }
5485     }
5486 
5487     @Test(dataProvider = "shortUnaryOpProvider")
5488     static void toDoubleArrayShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5489         short[] a = fa.apply(SPECIES.length());
5490 
5491         for (int i = 0; i < a.length; i += SPECIES.length()) {
5492             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5493             double[] r = av.toDoubleArray();
5494             assertArraysEquals(r, a, i);
5495         }
5496     }
5497 
5498     @Test(dataProvider = "shortUnaryOpProvider")
5499     static void toStringShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5500         short[] a = fa.apply(SPECIES.length());
5501 
5502         for (int i = 0; i < a.length; i += SPECIES.length()) {
5503             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5504             String str = av.toString();
5505 
5506             short subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5507             Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5508         }
5509     }
5510 
5511     @Test(dataProvider = "shortUnaryOpProvider")
5512     static void hashCodeShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5513         short[] a = fa.apply(SPECIES.length());
5514 
5515         for (int i = 0; i < a.length; i += SPECIES.length()) {
5516             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5517             int hash = av.hashCode();
5518 
5519             short subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5520             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5521             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5522         }
5523     }
5524 
5525 
5526     static long ADDReduceLong(short[] a, int idx) {
5527         short res = 0;
5528         for (int i = idx; i < (idx + SPECIES.length()); i++) {
5529             res += a[i];
5530         }
5531 
5532         return (long)res;
5533     }
5534 
5535     static long ADDReduceAllLong(short[] a) {
5536         long res = 0;
5537         for (int i = 0; i < a.length; i += SPECIES.length()) {
5538             res += ADDReduceLong(a, i);
5539         }
5540 
5541         return res;
5542     }
5543 
5544     @Test(dataProvider = "shortUnaryOpProvider")
5545     static void ADDReduceLongShortMaxVectorTests(IntFunction<short[]> fa) {
5546         short[] a = fa.apply(SPECIES.length());
5547         long[] r = lfr.apply(SPECIES.length());
5548         long ra = 0;
5549 
5550         for (int i = 0; i < a.length; i += SPECIES.length()) {
5551             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5552             r[i] = av.reduceLanesToLong(VectorOperators.ADD);
5553         }
5554 
5555         ra = 0;
5556         for (int i = 0; i < a.length; i ++) {
5557             ra += r[i];
5558         }
5559 
5560         assertReductionLongArraysEquals(r, ra, a,
5561                 ShortMaxVectorTests::ADDReduceLong, ShortMaxVectorTests::ADDReduceAllLong);
5562     }
5563 
5564     static long ADDReduceLongMasked(short[] a, int idx, boolean[] mask) {
5565         short res = 0;
5566         for (int i = idx; i < (idx + SPECIES.length()); i++) {
5567             if(mask[i % SPECIES.length()])
5568                 res += a[i];
5569         }
5570 
5571         return (long)res;
5572     }
5573 
5574     static long ADDReduceAllLongMasked(short[] a, boolean[] mask) {
5575         long res = 0;
5576         for (int i = 0; i < a.length; i += SPECIES.length()) {
5577             res += ADDReduceLongMasked(a, i, mask);
5578         }
5579 
5580         return res;
5581     }
5582 
5583     @Test(dataProvider = "shortUnaryOpMaskProvider")
5584     static void ADDReduceLongShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
5585         short[] a = fa.apply(SPECIES.length());
5586         long[] r = lfr.apply(SPECIES.length());
5587         boolean[] mask = fm.apply(SPECIES.length());
5588         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5589         long ra = 0;
5590 
5591         for (int i = 0; i < a.length; i += SPECIES.length()) {
5592             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5593             r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
5594         }
5595 
5596         ra = 0;
5597         for (int i = 0; i < a.length; i ++) {
5598             ra += r[i];
5599         }
5600 
5601         assertReductionLongArraysEqualsMasked(r, ra, a, mask,
5602                 ShortMaxVectorTests::ADDReduceLongMasked, ShortMaxVectorTests::ADDReduceAllLongMasked);
5603     }
5604 
5605     @Test(dataProvider = "shortUnaryOpProvider")
5606     static void BroadcastLongShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5607         short[] a = fa.apply(SPECIES.length());
5608         short[] r = new short[a.length];
5609 
5610         for (int i = 0; i < a.length; i += SPECIES.length()) {
5611             ShortVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
5612         }
5613         assertBroadcastArraysEquals(r, a);
5614     }
5615 
5616     @Test(dataProvider = "shortBinaryOpMaskProvider")
5617     static void blendShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5618                                           IntFunction<boolean[]> fm) {
5619         short[] a = fa.apply(SPECIES.length());
5620         short[] b = fb.apply(SPECIES.length());
5621         short[] r = fr.apply(SPECIES.length());
5622         boolean[] mask = fm.apply(SPECIES.length());
5623         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5624 
5625         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5626             for (int i = 0; i < a.length; i += SPECIES.length()) {
5627                 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5628                 av.blend((long)b[i], vmask).intoArray(r, i);
5629             }
5630         }
5631         assertBroadcastLongArraysEquals(r, a, b, mask, ShortMaxVectorTests::blend);
5632     }
5633 
5634 
5635     @Test(dataProvider = "shortUnaryOpSelectFromProvider")
5636     static void SelectFromShortMaxVectorTests(IntFunction<short[]> fa,
5637                                            BiFunction<Integer,Integer,short[]> fs) {
5638         short[] a = fa.apply(SPECIES.length());
5639         short[] order = fs.apply(a.length, SPECIES.length());
5640         short[] r = fr.apply(SPECIES.length());
5641 
5642         for (int i = 0; i < a.length; i += SPECIES.length()) {
5643             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5644             ShortVector bv = ShortVector.fromArray(SPECIES, order, i);
5645             bv.selectFrom(av).intoArray(r, i);
5646         }
5647 
5648         assertSelectFromArraysEquals(r, a, order, SPECIES.length());
5649     }
5650 
5651     @Test(dataProvider = "shortUnaryOpSelectFromMaskProvider")
5652     static void SelectFromShortMaxVectorTestsMaskedSmokeTest(IntFunction<short[]> fa,
5653                                                            BiFunction<Integer,Integer,short[]> fs,
5654                                                            IntFunction<boolean[]> fm) {
5655         short[] a = fa.apply(SPECIES.length());
5656         short[] order = fs.apply(a.length, SPECIES.length());
5657         short[] r = fr.apply(SPECIES.length());
5658         boolean[] mask = fm.apply(SPECIES.length());
5659         VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5660 
5661         for (int i = 0; i < a.length; i += SPECIES.length()) {
5662             ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5663             ShortVector bv = ShortVector.fromArray(SPECIES, order, i);
5664             bv.selectFrom(av, vmask).intoArray(r, i);
5665         }
5666 
5667         assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
5668     }
5669 
5670     @Test(dataProvider = "shuffleProvider")
5671     static void shuffleMiscellaneousShortMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5672         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5673 
5674         for (int i = 0; i < a.length; i += SPECIES.length()) {
5675             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5676             int hash = shuffle.hashCode();
5677             int length = shuffle.length();
5678 
5679             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5680             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5681             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5682             Assert.assertEquals(length, SPECIES.length());
5683         }
5684     }
5685 
5686     @Test(dataProvider = "shuffleProvider")
5687     static void shuffleToStringShortMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5688         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5689 
5690         for (int i = 0; i < a.length; i += SPECIES.length()) {
5691             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5692             String str = shuffle.toString();
5693 
5694             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5695             Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
5696                 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5697         }
5698     }
5699 
5700     @Test(dataProvider = "shuffleCompareOpProvider")
5701     static void shuffleEqualsShortMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
5702         int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5703         int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5704 
5705         for (int i = 0; i < a.length; i += SPECIES.length()) {
5706             var av = VectorShuffle.fromArray(SPECIES, a, i);
5707             var bv = VectorShuffle.fromArray(SPECIES, b, i);
5708             boolean eq = av.equals(bv);
5709             int to = i + SPECIES.length();
5710             Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
5711         }
5712     }
5713 
5714     @Test(dataProvider = "maskCompareOpProvider")
5715     static void maskEqualsShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5716         boolean[] a = fa.apply(SPECIES.length());
5717         boolean[] b = fb.apply(SPECIES.length());
5718 
5719         for (int i = 0; i < a.length; i += SPECIES.length()) {
5720             var av = SPECIES.loadMask(a, i);
5721             var bv = SPECIES.loadMask(b, i);
5722             boolean equals = av.equals(bv);
5723             int to = i + SPECIES.length();
5724             Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
5725         }
5726     }
5727 
5728     static boolean beq(boolean a, boolean b) {
5729         return (a == b);
5730     }
5731 
5732     @Test(dataProvider = "maskCompareOpProvider")
5733     static void maskEqShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5734         boolean[] a = fa.apply(SPECIES.length());
5735         boolean[] b = fb.apply(SPECIES.length());
5736         boolean[] r = new boolean[a.length];
5737 
5738         for (int i = 0; i < a.length; i += SPECIES.length()) {
5739             var av = SPECIES.loadMask(a, i);
5740             var bv = SPECIES.loadMask(b, i);
5741             var cv = av.eq(bv);
5742             cv.intoArray(r, i);
5743         }
5744         assertArraysEquals(r, a, b, ShortMaxVectorTests::beq);
5745     }
5746 
5747     @Test(dataProvider = "maskProvider")
5748     static void maskHashCodeShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5749         boolean[] a = fa.apply(SPECIES.length());
5750 
5751         for (int i = 0; i < a.length; i += SPECIES.length()) {
5752             var vmask = SPECIES.loadMask(a, i);
5753             int hash = vmask.hashCode();
5754 
5755             boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5756             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5757             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5758         }
5759     }
5760 
5761     static int maskTrueCount(boolean[] a, int idx) {
5762         int trueCount = 0;
5763         for (int i = idx; i < idx + SPECIES.length(); i++) {
5764             trueCount += a[i] ? 1 : 0;
5765         }
5766         return trueCount;
5767     }
5768 
5769     @Test(dataProvider = "maskProvider")
5770     static void maskTrueCountShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5771         boolean[] a = fa.apply(SPECIES.length());
5772         int[] r = new int[a.length];
5773 
5774         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5775             for (int i = 0; i < a.length; i += SPECIES.length()) {
5776                 var vmask = SPECIES.loadMask(a, i);
5777                 r[i] = vmask.trueCount();
5778             }
5779         }
5780 
5781         assertMaskReductionArraysEquals(r, a, ShortMaxVectorTests::maskTrueCount);
5782     }
5783 
5784     static int maskLastTrue(boolean[] a, int idx) {
5785         int i = idx + SPECIES.length() - 1;
5786         for (; i >= idx; i--) {
5787             if (a[i]) {
5788                 break;
5789             }
5790         }
5791         return i - idx;
5792     }
5793 
5794     @Test(dataProvider = "maskProvider")
5795     static void maskLastTrueShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5796         boolean[] a = fa.apply(SPECIES.length());
5797         int[] r = new int[a.length];
5798 
5799         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5800             for (int i = 0; i < a.length; i += SPECIES.length()) {
5801                 var vmask = SPECIES.loadMask(a, i);
5802                 r[i] = vmask.lastTrue();
5803             }
5804         }
5805 
5806         assertMaskReductionArraysEquals(r, a, ShortMaxVectorTests::maskLastTrue);
5807     }
5808 
5809     static int maskFirstTrue(boolean[] a, int idx) {
5810         int i = idx;
5811         for (; i < idx + SPECIES.length(); i++) {
5812             if (a[i]) {
5813                 break;
5814             }
5815         }
5816         return i - idx;
5817     }
5818 
5819     @Test(dataProvider = "maskProvider")
5820     static void maskFirstTrueShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5821         boolean[] a = fa.apply(SPECIES.length());
5822         int[] r = new int[a.length];
5823 
5824         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5825             for (int i = 0; i < a.length; i += SPECIES.length()) {
5826                 var vmask = SPECIES.loadMask(a, i);
5827                 r[i] = vmask.firstTrue();
5828             }
5829         }
5830 
5831         assertMaskReductionArraysEquals(r, a, ShortMaxVectorTests::maskFirstTrue);
5832     }
5833 

















5834 
5835     @DataProvider
5836     public static Object[][] offsetProvider() {
5837         return new Object[][]{
5838                 {0},
5839                 {-1},
5840                 {+1},
5841                 {+2},
5842                 {-2},
5843         };
5844     }
5845 
5846     @Test(dataProvider = "offsetProvider")
5847     static void indexInRangeShortMaxVectorTestsSmokeTest(int offset) {
5848         int limit = SPECIES.length() * BUFFER_REPS;
5849         for (int i = 0; i < limit; i += SPECIES.length()) {
5850             var actualMask = SPECIES.indexInRange(i + offset, limit);
5851             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5852             assert(actualMask.equals(expectedMask));
5853             for (int j = 0; j < SPECIES.length(); j++)  {
5854                 int index = i + j + offset;
5855                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5856             }
5857         }
5858     }
5859 














5860     @DataProvider
5861     public static Object[][] lengthProvider() {
5862         return new Object[][]{
5863                 {0},
5864                 {1},
5865                 {32},
5866                 {37},
5867                 {1024},
5868                 {1024+1},
5869                 {1024+5},
5870         };
5871     }
5872 
5873     @Test(dataProvider = "lengthProvider")
5874     static void loopBoundShortMaxVectorTestsSmokeTest(int length) {
5875         int actualLoopBound = SPECIES.loopBound(length);
5876         int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
5877         Assert.assertEquals(actualLoopBound, expectedLoopBound);
5878     }
5879 








5880     @Test
5881     static void ElementSizeShortMaxVectorTestsSmokeTest() {
5882         ShortVector av = ShortVector.zero(SPECIES);
5883         int elsize = av.elementSize();
5884         Assert.assertEquals(elsize, Short.SIZE);
5885     }
5886 
5887     @Test
5888     static void VectorShapeShortMaxVectorTestsSmokeTest() {
5889         ShortVector av = ShortVector.zero(SPECIES);
5890         VectorShape vsh = av.shape();
5891         assert(vsh.equals(VectorShape.S_Max_BIT));
5892     }
5893 
5894     @Test
5895     static void ShapeWithLanesShortMaxVectorTestsSmokeTest() {
5896         ShortVector av = ShortVector.zero(SPECIES);
5897         VectorShape vsh = av.shape();
5898         VectorSpecies species = vsh.withLanes(short.class);
5899         assert(species.equals(SPECIES));
5900     }
5901 
5902     @Test
5903     static void ElementTypeShortMaxVectorTestsSmokeTest() {
5904         ShortVector av = ShortVector.zero(SPECIES);
5905         assert(av.species().elementType() == short.class);
5906     }
5907 
5908     @Test
5909     static void SpeciesElementSizeShortMaxVectorTestsSmokeTest() {
5910         ShortVector av = ShortVector.zero(SPECIES);
5911         assert(av.species().elementSize() == Short.SIZE);
5912     }
5913 
5914     @Test
5915     static void VectorTypeShortMaxVectorTestsSmokeTest() {
5916         ShortVector av = ShortVector.zero(SPECIES);
5917         assert(av.species().vectorType() == av.getClass());
5918     }
5919 
5920     @Test
5921     static void WithLanesShortMaxVectorTestsSmokeTest() {
5922         ShortVector av = ShortVector.zero(SPECIES);
5923         VectorSpecies species = av.species().withLanes(short.class);
5924         assert(species.equals(SPECIES));
5925     }
5926 
5927     @Test
5928     static void WithShapeShortMaxVectorTestsSmokeTest() {
5929         ShortVector av = ShortVector.zero(SPECIES);
5930         VectorShape vsh = av.shape();
5931         VectorSpecies species = av.species().withShape(vsh);
5932         assert(species.equals(SPECIES));
5933     }
5934 
5935     @Test
5936     static void MaskAllTrueShortMaxVectorTestsSmokeTest() {
5937         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5938           Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
5939         }
5940     }
5941 }
5942 
--- EOF ---