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 ByteMaxVectorTests
  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.ByteVector;
  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 ByteMaxVectorTests extends AbstractVectorTest {
  56 
  57     static final VectorSpecies<Byte> SPECIES =
  58                 ByteVector.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 byte CONST_SHIFT = Byte.SIZE / 2;
  69 
  70     static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / Max);
  71 
  72     interface FUnOp {
  73         byte apply(byte a);
  74     }
  75 
  76     static void assertArraysEquals(byte[] r, byte[] 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         byte[] apply(byte a);
  89     }
  90 
  91     static void assertArraysEquals(byte[] r, byte[] 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             byte[] ref = f.apply(a[i]);
 100             byte[] 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(byte[] r, byte[] 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         byte apply(byte[] a, int idx);
 120     }
 121 
 122     interface FReductionAllOp {
 123         byte apply(byte[] a);
 124     }
 125 
 126     static void assertReductionArraysEquals(byte[] r, byte rc, byte[] 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         byte apply(byte[] a, int idx, boolean[] mask);
 142     }
 143 
 144     interface FReductionAllMaskedOp {
 145         byte apply(byte[] a, boolean[] mask);
 146     }
 147 
 148     static void assertReductionArraysEqualsMasked(byte[] r, byte rc, byte[] 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(byte[] a, int idx);
 164     }
 165 
 166     interface FReductionAllOpLong {
 167         long apply(byte[] a);
 168     }
 169 
 170     static void assertReductionLongArraysEquals(long[] r, long rc, byte[] 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(byte[] a, int idx, boolean[] mask);
 186     }
 187 
 188     interface FReductionAllMaskedOpLong {
 189         long apply(byte[] a, boolean[] mask);
 190     }
 191 
 192     static void assertReductionLongArraysEqualsMasked(long[] r, long rc, byte[] 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(byte[] r, byte[] a, byte 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(byte[] r, byte[] 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 assertcompressArraysEquals(byte[] r, byte[] a, boolean[] m, int vector_len) {
 270         int i = 0, j = 0, k = 0;
 271         try {
 272             for (; i < a.length; i += vector_len) {
 273                 k = 0;
 274                 for (j = 0; j < vector_len; j++) {
 275                     if (m[(i + j) % SPECIES.length()]) {
 276                         Assert.assertEquals(r[i + k], a[i + j]);
 277                         k++;
 278                     }
 279                 }
 280                 for (; k < vector_len; k++) {
 281                     Assert.assertEquals(r[i + k], (byte)0);
 282                 }
 283             }
 284         } catch (AssertionError e) {
 285             int idx = i + k;
 286             if (m[(i + j) % SPECIES.length()]) {
 287                 Assert.assertEquals(r[idx], a[i + j], "at index #" + idx);
 288             } else {
 289                 Assert.assertEquals(r[idx], (byte)0, "at index #" + idx);
 290             }
 291         }
 292     }
 293 
 294     static void assertexpandArraysEquals(byte[] r, byte[] a, boolean[] m, int vector_len) {
 295         int i = 0, j = 0, k = 0;
 296         try {
 297             for (; i < a.length; i += vector_len) {
 298                 k = 0;
 299                 for (j = 0; j < vector_len; j++) {
 300                     if (m[(i + j) % SPECIES.length()]) {
 301                         Assert.assertEquals(r[i + j], a[i + k]);
 302                         k++;
 303                     } else {
 304                         Assert.assertEquals(r[i + j], (byte)0);
 305                     }
 306                 }
 307             }
 308         } catch (AssertionError e) {
 309             int idx = i + j;
 310             if (m[idx % SPECIES.length()]) {
 311                 Assert.assertEquals(r[idx], a[i + k], "at index #" + idx);
 312             } else {
 313                 Assert.assertEquals(r[idx], (byte)0, "at index #" + idx);
 314             }
 315         }
 316     }
 317 
 318     static void assertSelectFromArraysEquals(byte[] r, byte[] a, byte[] order, int vector_len) {
 319         int i = 0, j = 0;
 320         try {
 321             for (; i < a.length; i += vector_len) {
 322                 for (j = 0; j < vector_len; j++) {
 323                     Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 324                 }
 325             }
 326         } catch (AssertionError e) {
 327             int idx = i + j;
 328             Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
 329         }
 330     }
 331 
 332     static void assertRearrangeArraysEquals(byte[] r, byte[] a, int[] order, boolean[] mask, int vector_len) {
 333         int i = 0, j = 0;
 334         try {
 335             for (; i < a.length; i += vector_len) {
 336                 for (j = 0; j < vector_len; j++) {
 337                     if (mask[j % SPECIES.length()])
 338                          Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 339                     else
 340                          Assert.assertEquals(r[i+j], (byte)0);
 341                 }
 342             }
 343         } catch (AssertionError e) {
 344             int idx = i + j;
 345             if (mask[j % SPECIES.length()])
 346                 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 347             else
 348                 Assert.assertEquals(r[i+j], (byte)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 349         }
 350     }
 351 
 352     static void assertSelectFromArraysEquals(byte[] r, byte[] a, byte[] order, boolean[] mask, int vector_len) {
 353         int i = 0, j = 0;
 354         try {
 355             for (; i < a.length; i += vector_len) {
 356                 for (j = 0; j < vector_len; j++) {
 357                     if (mask[j % SPECIES.length()])
 358                          Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 359                     else
 360                          Assert.assertEquals(r[i+j], (byte)0);
 361                 }
 362             }
 363         } catch (AssertionError e) {
 364             int idx = i + j;
 365             if (mask[j % SPECIES.length()])
 366                 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()]);
 367             else
 368                 Assert.assertEquals(r[i+j], (byte)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 369         }
 370     }
 371 
 372     static void assertBroadcastArraysEquals(byte[] r, byte[] a) {
 373         int i = 0;
 374         for (; i < a.length; i += SPECIES.length()) {
 375             int idx = i;
 376             for (int j = idx; j < (idx + SPECIES.length()); j++)
 377                 a[j]=a[idx];
 378         }
 379 
 380         try {
 381             for (i = 0; i < a.length; i++) {
 382                 Assert.assertEquals(r[i], a[i]);
 383             }
 384         } catch (AssertionError e) {
 385             Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
 386         }
 387     }
 388 
 389     interface FBinOp {
 390         byte apply(byte a, byte b);
 391     }
 392 
 393     interface FBinMaskOp {
 394         byte apply(byte a, byte b, boolean m);
 395 
 396         static FBinMaskOp lift(FBinOp f) {
 397             return (a, b, m) -> m ? f.apply(a, b) : a;
 398         }
 399     }
 400 
 401     static void assertArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
 402         int i = 0;
 403         try {
 404             for (; i < a.length; i++) {
 405                 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
 406             }
 407         } catch (AssertionError e) {
 408             Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
 409         }
 410     }
 411 
 412     static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
 413         int i = 0;
 414         try {
 415             for (; i < a.length; i++) {
 416                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
 417             }
 418         } catch (AssertionError e) {
 419             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
 420                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 421         }
 422     }
 423 
 424     static void assertBroadcastLongArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
 425         int i = 0;
 426         try {
 427             for (; i < a.length; i++) {
 428                 Assert.assertEquals(r[i], f.apply(a[i], (byte)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
 429             }
 430         } catch (AssertionError e) {
 431             Assert.assertEquals(r[i], f.apply(a[i], (byte)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
 432                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 433         }
 434     }
 435 
 436     static void assertArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinOp f) {
 437         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 438     }
 439 
 440     static void assertArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinMaskOp f) {
 441         int i = 0;
 442         try {
 443             for (; i < a.length; i++) {
 444                 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
 445             }
 446         } catch (AssertionError err) {
 447             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()]);
 448         }
 449     }
 450 
 451     static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinOp f) {
 452         assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 453     }
 454 
 455     static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinMaskOp f) {
 456         int i = 0;
 457         try {
 458             for (; i < a.length; i++) {
 459                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 460             }
 461         } catch (AssertionError err) {
 462             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 463                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 464                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 465                                 mask[i % SPECIES.length()]);
 466         }
 467     }
 468 
 469     static void assertBroadcastLongArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinOp f) {
 470         assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 471     }
 472 
 473     static void assertBroadcastLongArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinMaskOp f) {
 474         int i = 0;
 475         try {
 476             for (; i < a.length; i++) {
 477                 Assert.assertEquals(r[i], f.apply(a[i], (byte)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
 478             }
 479         } catch (AssertionError err) {
 480             Assert.assertEquals(r[i], f.apply(a[i], (byte)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
 481                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 482                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 483                                 mask[i % SPECIES.length()]);
 484         }
 485     }
 486 
 487     static void assertShiftArraysEquals(byte[] r, byte[] a, byte[] b, FBinOp f) {
 488         int i = 0;
 489         int j = 0;
 490         try {
 491             for (; j < a.length; j += SPECIES.length()) {
 492                 for (i = 0; i < SPECIES.length(); i++) {
 493                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
 494                 }
 495             }
 496         } catch (AssertionError e) {
 497             Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
 498         }
 499     }
 500 
 501     static void assertShiftArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinOp f) {
 502         assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 503     }
 504 
 505     static void assertShiftArraysEquals(byte[] r, byte[] a, byte[] b, boolean[] mask, FBinMaskOp f) {
 506         int i = 0;
 507         int j = 0;
 508         try {
 509             for (; j < a.length; j += SPECIES.length()) {
 510                 for (i = 0; i < SPECIES.length(); i++) {
 511                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
 512                 }
 513             }
 514         } catch (AssertionError err) {
 515             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]);
 516         }
 517     }
 518 
 519     interface FBinConstOp {
 520         byte apply(byte a);
 521     }
 522 
 523     interface FBinConstMaskOp {
 524         byte apply(byte a, boolean m);
 525 
 526         static FBinConstMaskOp lift(FBinConstOp f) {
 527             return (a, m) -> m ? f.apply(a) : a;
 528         }
 529     }
 530 
 531     static void assertShiftConstEquals(byte[] r, byte[] a, FBinConstOp f) {
 532         int i = 0;
 533         int j = 0;
 534         try {
 535             for (; j < a.length; j += SPECIES.length()) {
 536                 for (i = 0; i < SPECIES.length(); i++) {
 537                     Assert.assertEquals(r[i+j], f.apply(a[i+j]));
 538                 }
 539             }
 540         } catch (AssertionError e) {
 541             Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
 542         }
 543     }
 544 
 545     static void assertShiftConstEquals(byte[] r, byte[] a, boolean[] mask, FBinConstOp f) {
 546         assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
 547     }
 548 
 549     static void assertShiftConstEquals(byte[] r, byte[] a, boolean[] mask, FBinConstMaskOp f) {
 550         int i = 0;
 551         int j = 0;
 552         try {
 553             for (; j < a.length; j += SPECIES.length()) {
 554                 for (i = 0; i < SPECIES.length(); i++) {
 555                     Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
 556                 }
 557             }
 558         } catch (AssertionError err) {
 559             Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
 560         }
 561     }
 562 
 563     interface FTernOp {
 564         byte apply(byte a, byte b, byte c);
 565     }
 566 
 567     interface FTernMaskOp {
 568         byte apply(byte a, byte b, byte c, boolean m);
 569 
 570         static FTernMaskOp lift(FTernOp f) {
 571             return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
 572         }
 573     }
 574 
 575     static void assertArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, FTernOp f) {
 576         int i = 0;
 577         try {
 578             for (; i < a.length; i++) {
 579                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
 580             }
 581         } catch (AssertionError e) {
 582             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 583         }
 584     }
 585 
 586     static void assertArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask, FTernOp f) {
 587         assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 588     }
 589 
 590     static void assertArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask, FTernMaskOp f) {
 591         int i = 0;
 592         try {
 593             for (; i < a.length; i++) {
 594                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
 595             }
 596         } catch (AssertionError err) {
 597             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
 598               + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 599         }
 600     }
 601 
 602     static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, FTernOp f) {
 603         int i = 0;
 604         try {
 605             for (; i < a.length; i++) {
 606                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
 607             }
 608         } catch (AssertionError e) {
 609             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
 610                                 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
 611                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 612         }
 613     }
 614 
 615     static void assertAltBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, FTernOp f) {
 616         int i = 0;
 617         try {
 618             for (; i < a.length; i++) {
 619                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
 620             }
 621         } catch (AssertionError e) {
 622             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
 623                                 i + ", input1 = " + a[i] + ", input2 = " +
 624                                 b[(i / SPECIES.length()) * SPECIES.length()] + ",  input3 = " + c[i]);
 625         }
 626     }
 627 
 628     static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
 629                                             FTernOp f) {
 630         assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 631     }
 632 
 633     static void assertBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
 634                                             FTernMaskOp f) {
 635         int i = 0;
 636         try {
 637             for (; i < a.length; i++) {
 638                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 639                                     mask[i % SPECIES.length()]));
 640             }
 641         } catch (AssertionError err) {
 642             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 643                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
 644                                 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 645                                 mask[i % SPECIES.length()]);
 646         }
 647     }
 648 
 649     static void assertAltBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
 650                                             FTernOp f) {
 651         assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 652     }
 653 
 654     static void assertAltBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
 655                                             FTernMaskOp f) {
 656         int i = 0;
 657         try {
 658             for (; i < a.length; i++) {
 659                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 660                                     mask[i % SPECIES.length()]));
 661             }
 662         } catch (AssertionError err) {
 663             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 664                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 665                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 666                                 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 667         }
 668     }
 669 
 670     static void assertDoubleBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, FTernOp f) {
 671         int i = 0;
 672         try {
 673             for (; i < a.length; i++) {
 674                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 675                                     c[(i / SPECIES.length()) * SPECIES.length()]));
 676             }
 677         } catch (AssertionError e) {
 678             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 679                                 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
 680                                 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
 681                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 682         }
 683     }
 684 
 685     static void assertDoubleBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
 686                                                   FTernOp f) {
 687         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 688     }
 689 
 690     static void assertDoubleBroadcastArraysEquals(byte[] r, byte[] a, byte[] b, byte[] c, boolean[] mask,
 691                                                   FTernMaskOp f) {
 692         int i = 0;
 693         try {
 694             for (; i < a.length; i++) {
 695                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 696                                     c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 697             }
 698         } catch (AssertionError err) {
 699             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 700                                 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
 701                                 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 702                                 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 703                                 mask[i % SPECIES.length()]);
 704         }
 705     }
 706 
 707 
 708 
 709     interface FBinArrayOp {
 710         byte apply(byte[] a, int b);
 711     }
 712 
 713     static void assertArraysEquals(byte[] r, byte[] a, FBinArrayOp f) {
 714         int i = 0;
 715         try {
 716             for (; i < a.length; i++) {
 717                 Assert.assertEquals(r[i], f.apply(a, i));
 718             }
 719         } catch (AssertionError e) {
 720             Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
 721         }
 722     }
 723 
 724     interface FGatherScatterOp {
 725         byte[] apply(byte[] a, int ix, int[] b, int iy);
 726     }
 727 
 728     static void assertArraysEquals(byte[] r, byte[] a, int[] b, FGatherScatterOp f) {
 729         int i = 0;
 730         try {
 731             for (; i < a.length; i += SPECIES.length()) {
 732                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 733                   f.apply(a, i, b, i));
 734             }
 735         } catch (AssertionError e) {
 736             byte[] ref = f.apply(a, i, b, i);
 737             byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 738             Assert.assertEquals(res, ref,
 739               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 740               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 741               + ", b: "
 742               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 743               + " at index #" + i);
 744         }
 745     }
 746 
 747     interface FGatherMaskedOp {
 748         byte[] apply(byte[] a, int ix, boolean[] mask, int[] b, int iy);
 749     }
 750 
 751     interface FScatterMaskedOp {
 752         byte[] apply(byte[] r, byte[] a, int ix, boolean[] mask, int[] b, int iy);
 753     }
 754 
 755     static void assertArraysEquals(byte[] r, byte[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
 756         int i = 0;
 757         try {
 758             for (; i < a.length; i += SPECIES.length()) {
 759                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 760                   f.apply(a, i, mask, b, i));
 761             }
 762         } catch (AssertionError e) {
 763             byte[] ref = f.apply(a, i, mask, b, i);
 764             byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 765             Assert.assertEquals(res, ref,
 766               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 767               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 768               + ", b: "
 769               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 770               + ", mask: "
 771               + Arrays.toString(mask)
 772               + " at index #" + i);
 773         }
 774     }
 775 
 776     static void assertArraysEquals(byte[] r, byte[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
 777         int i = 0;
 778         try {
 779             for (; i < a.length; i += SPECIES.length()) {
 780                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 781                   f.apply(r, a, i, mask, b, i));
 782             }
 783         } catch (AssertionError e) {
 784             byte[] ref = f.apply(r, a, i, mask, b, i);
 785             byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 786             Assert.assertEquals(res, ref,
 787               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 788               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 789               + ", b: "
 790               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 791               + ", r: "
 792               + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
 793               + ", mask: "
 794               + Arrays.toString(mask)
 795               + " at index #" + i);
 796         }
 797     }
 798 
 799     interface FLaneOp {
 800         byte[] apply(byte[] a, int origin, int idx);
 801     }
 802 
 803     static void assertArraysEquals(byte[] r, byte[] a, int origin, FLaneOp f) {
 804         int i = 0;
 805         try {
 806             for (; i < a.length; i += SPECIES.length()) {
 807                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 808                   f.apply(a, origin, i));
 809             }
 810         } catch (AssertionError e) {
 811             byte[] ref = f.apply(a, origin, i);
 812             byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 813             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 814               + ", res: " + Arrays.toString(res)
 815               + "), at index #" + i);
 816         }
 817     }
 818 
 819     interface FLaneBop {
 820         byte[] apply(byte[] a, byte[] b, int origin, int idx);
 821     }
 822 
 823     static void assertArraysEquals(byte[] r, byte[] a, byte[] b, int origin, FLaneBop f) {
 824         int i = 0;
 825         try {
 826             for (; i < a.length; i += SPECIES.length()) {
 827                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 828                   f.apply(a, b, origin, i));
 829             }
 830         } catch (AssertionError e) {
 831             byte[] ref = f.apply(a, b, origin, i);
 832             byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 833             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 834               + ", res: " + Arrays.toString(res)
 835               + "), at index #" + i
 836               + ", at origin #" + origin);
 837         }
 838     }
 839 
 840     interface FLaneMaskedBop {
 841         byte[] apply(byte[] a, byte[] b, int origin, boolean[] mask, int idx);
 842     }
 843 
 844     static void assertArraysEquals(byte[] r, byte[] a, byte[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
 845         int i = 0;
 846         try {
 847             for (; i < a.length; i += SPECIES.length()) {
 848                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 849                   f.apply(a, b, origin, mask, i));
 850             }
 851         } catch (AssertionError e) {
 852             byte[] ref = f.apply(a, b, origin, mask, i);
 853             byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 854             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 855               + ", res: " + Arrays.toString(res)
 856               + "), at index #" + i
 857               + ", at origin #" + origin);
 858         }
 859     }
 860 
 861     interface FLanePartBop {
 862         byte[] apply(byte[] a, byte[] b, int origin, int part, int idx);
 863     }
 864 
 865     static void assertArraysEquals(byte[] r, byte[] a, byte[] b, int origin, int part, FLanePartBop f) {
 866         int i = 0;
 867         try {
 868             for (; i < a.length; i += SPECIES.length()) {
 869                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 870                   f.apply(a, b, origin, part, i));
 871             }
 872         } catch (AssertionError e) {
 873             byte[] ref = f.apply(a, b, origin, part, i);
 874             byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 875             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 876               + ", res: " + Arrays.toString(res)
 877               + "), at index #" + i
 878               + ", at origin #" + origin
 879               + ", with part #" + part);
 880         }
 881     }
 882 
 883     interface FLanePartMaskedBop {
 884         byte[] apply(byte[] a, byte[] b, int origin, int part, boolean[] mask, int idx);
 885     }
 886 
 887     static void assertArraysEquals(byte[] r, byte[] a, byte[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
 888         int i = 0;
 889         try {
 890             for (; i < a.length; i += SPECIES.length()) {
 891                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 892                   f.apply(a, b, origin, part, mask, i));
 893             }
 894         } catch (AssertionError e) {
 895             byte[] ref = f.apply(a, b, origin, part, mask, i);
 896             byte[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 897             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 898               + ", res: " + Arrays.toString(res)
 899               + "), at index #" + i
 900               + ", at origin #" + origin
 901               + ", with part #" + part);
 902         }
 903     }
 904 
 905 
 906     static void assertArraysEquals(int[] r, byte[] a, int offs) {
 907         int i = 0;
 908         try {
 909             for (; i < r.length; i++) {
 910                 Assert.assertEquals(r[i], (int)(a[i+offs]));
 911             }
 912         } catch (AssertionError e) {
 913             Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 914         }
 915     }
 916 
 917 
 918     static void assertArraysEquals(byte[] r, byte[] a, int offs) {
 919         int i = 0;
 920         try {
 921             for (; i < r.length; i++) {
 922                 Assert.assertEquals(r[i], (long)(a[i+offs]));
 923             }
 924         } catch (AssertionError e) {
 925             Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 926         }
 927     }
 928 
 929     static void assertArraysEquals(long[] r, byte[] a, int offs) {
 930         int i = 0;
 931         try {
 932             for (; i < r.length; i++) {
 933                 Assert.assertEquals(r[i], (long)(a[i+offs]));
 934             }
 935         } catch (AssertionError e) {
 936             Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 937         }
 938     }
 939 
 940     static void assertArraysEquals(double[] r, byte[] a, int offs) {
 941         int i = 0;
 942         try {
 943             for (; i < r.length; i++) {
 944                 Assert.assertEquals(r[i], (double)(a[i+offs]));
 945             }
 946         } catch (AssertionError e) {
 947             Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
 948         }
 949     }
 950 
 951     static byte bits(byte e) {
 952         return  e;
 953     }
 954 
 955     static final List<IntFunction<byte[]>> BYTE_GENERATORS = List.of(
 956             withToString("byte[-i * 5]", (int s) -> {
 957                 return fill(s * BUFFER_REPS,
 958                             i -> (byte)(-i * 5));
 959             }),
 960             withToString("byte[i * 5]", (int s) -> {
 961                 return fill(s * BUFFER_REPS,
 962                             i -> (byte)(i * 5));
 963             }),
 964             withToString("byte[i + 1]", (int s) -> {
 965                 return fill(s * BUFFER_REPS,
 966                             i -> (((byte)(i + 1) == 0) ? 1 : (byte)(i + 1)));
 967             }),
 968             withToString("byte[cornerCaseValue(i)]", (int s) -> {
 969                 return fill(s * BUFFER_REPS,
 970                             i -> cornerCaseValue(i));
 971             })
 972     );
 973 
 974     // Create combinations of pairs
 975     // @@@ Might be sensitive to order e.g. div by 0
 976     static final List<List<IntFunction<byte[]>>> BYTE_GENERATOR_PAIRS =
 977         Stream.of(BYTE_GENERATORS.get(0)).
 978                 flatMap(fa -> BYTE_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
 979                 collect(Collectors.toList());
 980 
 981     @DataProvider
 982     public Object[][] boolUnaryOpProvider() {
 983         return BOOL_ARRAY_GENERATORS.stream().
 984                 map(f -> new Object[]{f}).
 985                 toArray(Object[][]::new);
 986     }
 987 
 988     static final List<List<IntFunction<byte[]>>> BYTE_GENERATOR_TRIPLES =
 989         BYTE_GENERATOR_PAIRS.stream().
 990                 flatMap(pair -> BYTE_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
 991                 collect(Collectors.toList());
 992 
 993     @DataProvider
 994     public Object[][] byteBinaryOpProvider() {
 995         return BYTE_GENERATOR_PAIRS.stream().map(List::toArray).
 996                 toArray(Object[][]::new);
 997     }
 998 
 999     @DataProvider
1000     public Object[][] byteIndexedOpProvider() {
1001         return BYTE_GENERATOR_PAIRS.stream().map(List::toArray).
1002                 toArray(Object[][]::new);
1003     }
1004 
1005     @DataProvider
1006     public Object[][] byteBinaryOpMaskProvider() {
1007         return BOOLEAN_MASK_GENERATORS.stream().
1008                 flatMap(fm -> BYTE_GENERATOR_PAIRS.stream().map(lfa -> {
1009                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1010                 })).
1011                 toArray(Object[][]::new);
1012     }
1013 
1014     @DataProvider
1015     public Object[][] byteTernaryOpProvider() {
1016         return BYTE_GENERATOR_TRIPLES.stream().map(List::toArray).
1017                 toArray(Object[][]::new);
1018     }
1019 
1020     @DataProvider
1021     public Object[][] byteTernaryOpMaskProvider() {
1022         return BOOLEAN_MASK_GENERATORS.stream().
1023                 flatMap(fm -> BYTE_GENERATOR_TRIPLES.stream().map(lfa -> {
1024                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1025                 })).
1026                 toArray(Object[][]::new);
1027     }
1028 
1029     @DataProvider
1030     public Object[][] byteUnaryOpProvider() {
1031         return BYTE_GENERATORS.stream().
1032                 map(f -> new Object[]{f}).
1033                 toArray(Object[][]::new);
1034     }
1035 
1036     @DataProvider
1037     public Object[][] byteUnaryOpMaskProvider() {
1038         return BOOLEAN_MASK_GENERATORS.stream().
1039                 flatMap(fm -> BYTE_GENERATORS.stream().map(fa -> {
1040                     return new Object[] {fa, fm};
1041                 })).
1042                 toArray(Object[][]::new);
1043     }
1044 
1045     @DataProvider
1046     public Object[][] maskProvider() {
1047         return BOOLEAN_MASK_GENERATORS.stream().
1048                 map(f -> new Object[]{f}).
1049                 toArray(Object[][]::new);
1050     }
1051 
1052     @DataProvider
1053     public Object[][] maskCompareOpProvider() {
1054         return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1055                 toArray(Object[][]::new);
1056     }
1057 
1058     @DataProvider
1059     public Object[][] shuffleProvider() {
1060         return INT_SHUFFLE_GENERATORS.stream().
1061                 map(f -> new Object[]{f}).
1062                 toArray(Object[][]::new);
1063     }
1064 
1065     @DataProvider
1066     public Object[][] shuffleCompareOpProvider() {
1067         return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1068                 toArray(Object[][]::new);
1069     }
1070 
1071     @DataProvider
1072     public Object[][] byteUnaryOpShuffleProvider() {
1073         return INT_SHUFFLE_GENERATORS.stream().
1074                 flatMap(fs -> BYTE_GENERATORS.stream().map(fa -> {
1075                     return new Object[] {fa, fs};
1076                 })).
1077                 toArray(Object[][]::new);
1078     }
1079 
1080     @DataProvider
1081     public Object[][] byteUnaryOpShuffleMaskProvider() {
1082         return BOOLEAN_MASK_GENERATORS.stream().
1083                 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1084                     flatMap(fs -> BYTE_GENERATORS.stream().map(fa -> {
1085                         return new Object[] {fa, fs, fm};
1086                 }))).
1087                 toArray(Object[][]::new);
1088     }
1089 
1090     static final List<BiFunction<Integer,Integer,byte[]>> BYTE_SHUFFLE_GENERATORS = List.of(
1091             withToStringBi("shuffle[random]", (Integer l, Integer m) -> {
1092                 byte[] a = new byte[l];
1093                 int upper = Math.min(Byte.MAX_VALUE + 1, m);
1094                 for (int i = 0; i < 1; i++) {
1095                     a[i] = (byte)RAND.nextInt(upper);
1096                 }
1097                 return a;
1098             })
1099     );
1100 
1101     @DataProvider
1102     public Object[][] byteUnaryOpSelectFromProvider() {
1103         return BYTE_SHUFFLE_GENERATORS.stream().
1104                 flatMap(fs -> BYTE_GENERATORS.stream().map(fa -> {
1105                     return new Object[] {fa, fs};
1106                 })).
1107                 toArray(Object[][]::new);
1108     }
1109 
1110     @DataProvider
1111     public Object[][] byteUnaryOpSelectFromMaskProvider() {
1112         return BOOLEAN_MASK_GENERATORS.stream().
1113                 flatMap(fm -> BYTE_SHUFFLE_GENERATORS.stream().
1114                     flatMap(fs -> BYTE_GENERATORS.stream().map(fa -> {
1115                         return new Object[] {fa, fs, fm};
1116                 }))).
1117                 toArray(Object[][]::new);
1118     }
1119 
1120     static final List<IntFunction<byte[]>> BYTE_COMPARE_GENERATORS = List.of(
1121             withToString("byte[i]", (int s) -> {
1122                 return fill(s * BUFFER_REPS,
1123                             i -> (byte)i);
1124             }),
1125             withToString("byte[i - length / 2]", (int s) -> {
1126                 return fill(s * BUFFER_REPS,
1127                             i -> (byte)(i - (s * BUFFER_REPS / 2)));
1128             }),
1129             withToString("byte[i + 1]", (int s) -> {
1130                 return fill(s * BUFFER_REPS,
1131                             i -> (byte)(i + 1));
1132             }),
1133             withToString("byte[i - 2]", (int s) -> {
1134                 return fill(s * BUFFER_REPS,
1135                             i -> (byte)(i - 2));
1136             }),
1137             withToString("byte[zigZag(i)]", (int s) -> {
1138                 return fill(s * BUFFER_REPS,
1139                             i -> i%3 == 0 ? (byte)i : (i%3 == 1 ? (byte)(i + 1) : (byte)(i - 2)));
1140             }),
1141             withToString("byte[cornerCaseValue(i)]", (int s) -> {
1142                 return fill(s * BUFFER_REPS,
1143                             i -> cornerCaseValue(i));
1144             })
1145     );
1146 
1147     static final List<List<IntFunction<byte[]>>> BYTE_TEST_GENERATOR_ARGS =
1148         BYTE_COMPARE_GENERATORS.stream().
1149                 map(fa -> List.of(fa)).
1150                 collect(Collectors.toList());
1151 
1152     @DataProvider
1153     public Object[][] byteTestOpProvider() {
1154         return BYTE_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1155                 toArray(Object[][]::new);
1156     }
1157 
1158     @DataProvider
1159     public Object[][] byteTestOpMaskProvider() {
1160         return BOOLEAN_MASK_GENERATORS.stream().
1161                 flatMap(fm -> BYTE_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1162                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1163                 })).
1164                 toArray(Object[][]::new);
1165     }
1166 
1167     static final List<List<IntFunction<byte[]>>> BYTE_COMPARE_GENERATOR_PAIRS =
1168         BYTE_COMPARE_GENERATORS.stream().
1169                 flatMap(fa -> BYTE_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1170                 collect(Collectors.toList());
1171 
1172     @DataProvider
1173     public Object[][] byteCompareOpProvider() {
1174         return BYTE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1175                 toArray(Object[][]::new);
1176     }
1177 
1178     @DataProvider
1179     public Object[][] byteCompareOpMaskProvider() {
1180         return BOOLEAN_MASK_GENERATORS.stream().
1181                 flatMap(fm -> BYTE_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1182                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1183                 })).
1184                 toArray(Object[][]::new);
1185     }
1186 
1187     interface ToByteF {
1188         byte apply(int i);
1189     }
1190 
1191     static byte[] fill(int s , ToByteF f) {
1192         return fill(new byte[s], f);
1193     }
1194 
1195     static byte[] fill(byte[] a, ToByteF f) {
1196         for (int i = 0; i < a.length; i++) {
1197             a[i] = f.apply(i);
1198         }
1199         return a;
1200     }
1201 
1202     static byte cornerCaseValue(int i) {
1203         switch(i % 5) {
1204             case 0:
1205                 return Byte.MAX_VALUE;
1206             case 1:
1207                 return Byte.MIN_VALUE;
1208             case 2:
1209                 return Byte.MIN_VALUE;
1210             case 3:
1211                 return Byte.MAX_VALUE;
1212             default:
1213                 return (byte)0;
1214         }
1215     }
1216 
1217     static byte get(byte[] a, int i) {
1218         return (byte) a[i];
1219     }
1220 
1221     static final IntFunction<byte[]> fr = (vl) -> {
1222         int length = BUFFER_REPS * vl;
1223         return new byte[length];
1224     };
1225 
1226     static final IntFunction<boolean[]> fmr = (vl) -> {
1227         int length = BUFFER_REPS * vl;
1228         return new boolean[length];
1229     };
1230 
1231     static final IntFunction<long[]> lfr = (vl) -> {
1232         int length = BUFFER_REPS * vl;
1233         return new long[length];
1234     };
1235 
1236     static void replaceZero(byte[] a, byte v) {
1237         for (int i = 0; i < a.length; i++) {
1238             if (a[i] == 0) {
1239                 a[i] = v;
1240             }
1241         }
1242     }
1243 
1244     static void replaceZero(byte[] a, boolean[] mask, byte v) {
1245         for (int i = 0; i < a.length; i++) {
1246             if (mask[i % mask.length] && a[i] == 0) {
1247                 a[i] = v;
1248             }
1249         }
1250     }
1251 
1252     static byte ROL_scalar(byte a, byte b) {
1253         return (byte)(((((byte)a) & 0xFF) << (b & 7)) | ((((byte)a) & 0xFF) >>> (8 - (b & 7))));
1254     }
1255 
1256     static byte ROR_scalar(byte a, byte b) {
1257         return (byte)(((((byte)a) & 0xFF) >>> (b & 7)) | ((((byte)a) & 0xFF) << (8 - (b & 7))));
1258     }
1259 
1260     static byte TRAILING_ZEROS_COUNT_scalar(byte a) {
1261         return (byte) (a != 0 ? Integer.numberOfTrailingZeros(a) : 8);
1262     }
1263 
1264     static byte LEADING_ZEROS_COUNT_scalar(byte a) {
1265         return (byte) (a >= 0 ? Integer.numberOfLeadingZeros(a) - 24 : 0);
1266     }
1267 
1268     static byte REVERSE_scalar(byte a) {
1269         byte b = (byte) ROL_scalar(a, (byte) 4);
1270         b = (byte) (((b & 0x55) << 1) | ((b & 0xAA) >>> 1));
1271         b = (byte) (((b & 0x33) << 2) | ((b & 0xCC) >>> 2));
1272         return b;
1273     }
1274 
1275     static boolean eq(byte a, byte b) {
1276         return a == b;
1277     }
1278 
1279     static boolean neq(byte a, byte b) {
1280         return a != b;
1281     }
1282 
1283     static boolean lt(byte a, byte b) {
1284         return a < b;
1285     }
1286 
1287     static boolean le(byte a, byte b) {
1288         return a <= b;
1289     }
1290 
1291     static boolean gt(byte a, byte b) {
1292         return a > b;
1293     }
1294 
1295     static boolean ge(byte a, byte b) {
1296         return a >= b;
1297     }
1298 
1299     static boolean ult(byte a, byte b) {
1300         return Byte.compareUnsigned(a, b) < 0;
1301     }
1302 
1303     static boolean ule(byte a, byte b) {
1304         return Byte.compareUnsigned(a, b) <= 0;
1305     }
1306 
1307     static boolean ugt(byte a, byte b) {
1308         return Byte.compareUnsigned(a, b) > 0;
1309     }
1310 
1311     static boolean uge(byte a, byte b) {
1312         return Byte.compareUnsigned(a, b) >= 0;
1313     }
1314 
1315     static byte firstNonZero(byte a, byte b) {
1316         return Byte.compare(a, (byte) 0) != 0 ? a : b;
1317     }
1318 
1319     @Test
1320     static void smokeTest1() {
1321         ByteVector three = ByteVector.broadcast(SPECIES, (byte)-3);
1322         ByteVector three2 = (ByteVector) SPECIES.broadcast(-3);
1323         assert(three.eq(three2).allTrue());
1324         ByteVector three3 = three2.broadcast(1).broadcast(-3);
1325         assert(three.eq(three3).allTrue());
1326         int scale = 2;
1327         Class<?> ETYPE = byte.class;
1328         if (ETYPE == double.class || ETYPE == long.class)
1329             scale = 1000000;
1330         else if (ETYPE == byte.class && SPECIES.length() >= 64)
1331             scale = 1;
1332         ByteVector higher = three.addIndex(scale);
1333         VectorMask<Byte> m = three.compare(VectorOperators.LE, higher);
1334         assert(m.allTrue());
1335         m = higher.min((byte)-1).test(VectorOperators.IS_NEGATIVE);
1336         assert(m.allTrue());
1337         byte max = higher.reduceLanes(VectorOperators.MAX);
1338         assert(max == -3 + scale * (SPECIES.length()-1));
1339     }
1340 
1341     private static byte[]
1342     bothToArray(ByteVector a, ByteVector b) {
1343         byte[] r = new byte[a.length() + b.length()];
1344         a.intoArray(r, 0);
1345         b.intoArray(r, a.length());
1346         return r;
1347     }
1348 
1349     @Test
1350     static void smokeTest2() {
1351         // Do some zipping and shuffling.
1352         ByteVector io = (ByteVector) SPECIES.broadcast(0).addIndex(1);
1353         ByteVector io2 = (ByteVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1354         Assert.assertEquals(io, io2);
1355         ByteVector a = io.add((byte)1); //[1,2]
1356         ByteVector b = a.neg();  //[-1,-2]
1357         byte[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1358         VectorShuffle<Byte> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1359         VectorShuffle<Byte> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1360         ByteVector zab0 = a.rearrange(zip0,b); //[1,-1]
1361         ByteVector zab1 = a.rearrange(zip1,b); //[2,-2]
1362         byte[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1363         // manually zip
1364         byte[] manual = new byte[zabValues.length];
1365         for (int i = 0; i < manual.length; i += 2) {
1366             manual[i+0] = abValues[i/2];
1367             manual[i+1] = abValues[a.length() + i/2];
1368         }
1369         Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1370         VectorShuffle<Byte> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1371         VectorShuffle<Byte> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1372         ByteVector uab0 = zab0.rearrange(unz0,zab1);
1373         ByteVector uab1 = zab0.rearrange(unz1,zab1);
1374         byte[] abValues1 = bothToArray(uab0, uab1);
1375         Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1376     }
1377 
1378     static void iotaShuffle() {
1379         ByteVector io = (ByteVector) SPECIES.broadcast(0).addIndex(1);
1380         ByteVector io2 = (ByteVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1381         Assert.assertEquals(io, io2);
1382     }
1383 
1384     @Test
1385     // Test all shuffle related operations.
1386     static void shuffleTest() {
1387         // To test backend instructions, make sure that C2 is used.
1388         for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1389             iotaShuffle();
1390         }
1391     }
1392 
1393     @Test
1394     void viewAsIntegeralLanesTest() {
1395         Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1396         Assert.assertEquals(asIntegral.species(), SPECIES);
1397     }
1398 
1399     @Test(expectedExceptions = UnsupportedOperationException.class)
1400     void viewAsFloatingLanesTest() {
1401         SPECIES.zero().viewAsFloatingLanes();
1402     }
1403 
1404     @Test
1405     // Test div by 0.
1406     static void bitwiseDivByZeroSmokeTest() {
1407         try {
1408             ByteVector a = (ByteVector) SPECIES.broadcast(0).addIndex(1);
1409             ByteVector b = (ByteVector) SPECIES.broadcast(0);
1410             a.div(b);
1411             Assert.fail();
1412         } catch (ArithmeticException e) {
1413         }
1414 
1415         try {
1416             ByteVector a = (ByteVector) SPECIES.broadcast(0).addIndex(1);
1417             ByteVector b = (ByteVector) SPECIES.broadcast(0);
1418             VectorMask<Byte> m = a.lt((byte) 1);
1419             a.div(b, m);
1420             Assert.fail();
1421         } catch (ArithmeticException e) {
1422         }
1423     }
1424 
1425     static byte ADD(byte a, byte b) {
1426         return (byte)(a + b);
1427     }
1428 
1429     @Test(dataProvider = "byteBinaryOpProvider")
1430     static void ADDByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1431         byte[] a = fa.apply(SPECIES.length());
1432         byte[] b = fb.apply(SPECIES.length());
1433         byte[] r = fr.apply(SPECIES.length());
1434 
1435         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1436             for (int i = 0; i < a.length; i += SPECIES.length()) {
1437                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1438                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1439                 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1440             }
1441         }
1442 
1443         assertArraysEquals(r, a, b, ByteMaxVectorTests::ADD);
1444     }
1445 
1446     static byte add(byte a, byte b) {
1447         return (byte)(a + b);
1448     }
1449 
1450     @Test(dataProvider = "byteBinaryOpProvider")
1451     static void addByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1452         byte[] a = fa.apply(SPECIES.length());
1453         byte[] b = fb.apply(SPECIES.length());
1454         byte[] r = fr.apply(SPECIES.length());
1455 
1456         for (int i = 0; i < a.length; i += SPECIES.length()) {
1457             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1458             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1459             av.add(bv).intoArray(r, i);
1460         }
1461 
1462         assertArraysEquals(r, a, b, ByteMaxVectorTests::add);
1463     }
1464 
1465     @Test(dataProvider = "byteBinaryOpMaskProvider")
1466     static void ADDByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1467                                           IntFunction<boolean[]> fm) {
1468         byte[] a = fa.apply(SPECIES.length());
1469         byte[] b = fb.apply(SPECIES.length());
1470         byte[] r = fr.apply(SPECIES.length());
1471         boolean[] mask = fm.apply(SPECIES.length());
1472         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1473 
1474         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1475             for (int i = 0; i < a.length; i += SPECIES.length()) {
1476                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1477                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1478                 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1479             }
1480         }
1481 
1482         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::ADD);
1483     }
1484 
1485     @Test(dataProvider = "byteBinaryOpMaskProvider")
1486     static void addByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1487                                           IntFunction<boolean[]> fm) {
1488         byte[] a = fa.apply(SPECIES.length());
1489         byte[] b = fb.apply(SPECIES.length());
1490         byte[] r = fr.apply(SPECIES.length());
1491         boolean[] mask = fm.apply(SPECIES.length());
1492         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1493 
1494         for (int i = 0; i < a.length; i += SPECIES.length()) {
1495             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1496             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1497             av.add(bv, vmask).intoArray(r, i);
1498         }
1499 
1500         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::add);
1501     }
1502 
1503     static byte SUB(byte a, byte b) {
1504         return (byte)(a - b);
1505     }
1506 
1507     @Test(dataProvider = "byteBinaryOpProvider")
1508     static void SUBByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1509         byte[] a = fa.apply(SPECIES.length());
1510         byte[] b = fb.apply(SPECIES.length());
1511         byte[] r = fr.apply(SPECIES.length());
1512 
1513         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1514             for (int i = 0; i < a.length; i += SPECIES.length()) {
1515                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1516                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1517                 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1518             }
1519         }
1520 
1521         assertArraysEquals(r, a, b, ByteMaxVectorTests::SUB);
1522     }
1523 
1524     static byte sub(byte a, byte b) {
1525         return (byte)(a - b);
1526     }
1527 
1528     @Test(dataProvider = "byteBinaryOpProvider")
1529     static void subByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1530         byte[] a = fa.apply(SPECIES.length());
1531         byte[] b = fb.apply(SPECIES.length());
1532         byte[] r = fr.apply(SPECIES.length());
1533 
1534         for (int i = 0; i < a.length; i += SPECIES.length()) {
1535             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1536             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1537             av.sub(bv).intoArray(r, i);
1538         }
1539 
1540         assertArraysEquals(r, a, b, ByteMaxVectorTests::sub);
1541     }
1542 
1543     @Test(dataProvider = "byteBinaryOpMaskProvider")
1544     static void SUBByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1545                                           IntFunction<boolean[]> fm) {
1546         byte[] a = fa.apply(SPECIES.length());
1547         byte[] b = fb.apply(SPECIES.length());
1548         byte[] r = fr.apply(SPECIES.length());
1549         boolean[] mask = fm.apply(SPECIES.length());
1550         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1551 
1552         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1553             for (int i = 0; i < a.length; i += SPECIES.length()) {
1554                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1555                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1556                 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1557             }
1558         }
1559 
1560         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::SUB);
1561     }
1562 
1563     @Test(dataProvider = "byteBinaryOpMaskProvider")
1564     static void subByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1565                                           IntFunction<boolean[]> fm) {
1566         byte[] a = fa.apply(SPECIES.length());
1567         byte[] b = fb.apply(SPECIES.length());
1568         byte[] r = fr.apply(SPECIES.length());
1569         boolean[] mask = fm.apply(SPECIES.length());
1570         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1571 
1572         for (int i = 0; i < a.length; i += SPECIES.length()) {
1573             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1574             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1575             av.sub(bv, vmask).intoArray(r, i);
1576         }
1577 
1578         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::sub);
1579     }
1580 
1581     static byte MUL(byte a, byte b) {
1582         return (byte)(a * b);
1583     }
1584 
1585     @Test(dataProvider = "byteBinaryOpProvider")
1586     static void MULByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1587         byte[] a = fa.apply(SPECIES.length());
1588         byte[] b = fb.apply(SPECIES.length());
1589         byte[] r = fr.apply(SPECIES.length());
1590 
1591         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1592             for (int i = 0; i < a.length; i += SPECIES.length()) {
1593                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1594                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1595                 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1596             }
1597         }
1598 
1599         assertArraysEquals(r, a, b, ByteMaxVectorTests::MUL);
1600     }
1601 
1602     static byte mul(byte a, byte b) {
1603         return (byte)(a * b);
1604     }
1605 
1606     @Test(dataProvider = "byteBinaryOpProvider")
1607     static void mulByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1608         byte[] a = fa.apply(SPECIES.length());
1609         byte[] b = fb.apply(SPECIES.length());
1610         byte[] r = fr.apply(SPECIES.length());
1611 
1612         for (int i = 0; i < a.length; i += SPECIES.length()) {
1613             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1614             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1615             av.mul(bv).intoArray(r, i);
1616         }
1617 
1618         assertArraysEquals(r, a, b, ByteMaxVectorTests::mul);
1619     }
1620 
1621     @Test(dataProvider = "byteBinaryOpMaskProvider")
1622     static void MULByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1623                                           IntFunction<boolean[]> fm) {
1624         byte[] a = fa.apply(SPECIES.length());
1625         byte[] b = fb.apply(SPECIES.length());
1626         byte[] r = fr.apply(SPECIES.length());
1627         boolean[] mask = fm.apply(SPECIES.length());
1628         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1629 
1630         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1631             for (int i = 0; i < a.length; i += SPECIES.length()) {
1632                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1633                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1634                 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1635             }
1636         }
1637 
1638         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::MUL);
1639     }
1640 
1641     @Test(dataProvider = "byteBinaryOpMaskProvider")
1642     static void mulByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1643                                           IntFunction<boolean[]> fm) {
1644         byte[] a = fa.apply(SPECIES.length());
1645         byte[] b = fb.apply(SPECIES.length());
1646         byte[] r = fr.apply(SPECIES.length());
1647         boolean[] mask = fm.apply(SPECIES.length());
1648         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1649 
1650         for (int i = 0; i < a.length; i += SPECIES.length()) {
1651             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1652             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1653             av.mul(bv, vmask).intoArray(r, i);
1654         }
1655 
1656         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::mul);
1657     }
1658 
1659     static byte DIV(byte a, byte b) {
1660         return (byte)(a / b);
1661     }
1662 
1663     @Test(dataProvider = "byteBinaryOpProvider")
1664     static void DIVByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1665         byte[] a = fa.apply(SPECIES.length());
1666         byte[] b = fb.apply(SPECIES.length());
1667         byte[] r = fr.apply(SPECIES.length());
1668 
1669         replaceZero(b, (byte) 1);
1670 
1671         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1672             for (int i = 0; i < a.length; i += SPECIES.length()) {
1673                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1674                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1675                 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1676             }
1677         }
1678 
1679         assertArraysEquals(r, a, b, ByteMaxVectorTests::DIV);
1680     }
1681 
1682     static byte div(byte a, byte b) {
1683         return (byte)(a / b);
1684     }
1685 
1686     @Test(dataProvider = "byteBinaryOpProvider")
1687     static void divByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1688         byte[] a = fa.apply(SPECIES.length());
1689         byte[] b = fb.apply(SPECIES.length());
1690         byte[] r = fr.apply(SPECIES.length());
1691 
1692         replaceZero(b, (byte) 1);
1693 
1694         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1695             for (int i = 0; i < a.length; i += SPECIES.length()) {
1696                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1697                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1698                 av.div(bv).intoArray(r, i);
1699             }
1700         }
1701 
1702         assertArraysEquals(r, a, b, ByteMaxVectorTests::div);
1703     }
1704 
1705     @Test(dataProvider = "byteBinaryOpMaskProvider")
1706     static void DIVByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1707                                           IntFunction<boolean[]> fm) {
1708         byte[] a = fa.apply(SPECIES.length());
1709         byte[] b = fb.apply(SPECIES.length());
1710         byte[] r = fr.apply(SPECIES.length());
1711         boolean[] mask = fm.apply(SPECIES.length());
1712         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1713 
1714         replaceZero(b, mask, (byte) 1);
1715 
1716         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1717             for (int i = 0; i < a.length; i += SPECIES.length()) {
1718                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1719                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1720                 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1721             }
1722         }
1723 
1724         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::DIV);
1725     }
1726 
1727     @Test(dataProvider = "byteBinaryOpMaskProvider")
1728     static void divByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1729                                           IntFunction<boolean[]> fm) {
1730         byte[] a = fa.apply(SPECIES.length());
1731         byte[] b = fb.apply(SPECIES.length());
1732         byte[] r = fr.apply(SPECIES.length());
1733         boolean[] mask = fm.apply(SPECIES.length());
1734         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1735 
1736         replaceZero(b, mask, (byte) 1);
1737 
1738         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1739             for (int i = 0; i < a.length; i += SPECIES.length()) {
1740                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1741                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1742                 av.div(bv, vmask).intoArray(r, i);
1743             }
1744         }
1745 
1746         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::div);
1747     }
1748 
1749     static byte FIRST_NONZERO(byte a, byte b) {
1750         return (byte)((a)!=0?a:b);
1751     }
1752 
1753     @Test(dataProvider = "byteBinaryOpProvider")
1754     static void FIRST_NONZEROByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1755         byte[] a = fa.apply(SPECIES.length());
1756         byte[] b = fb.apply(SPECIES.length());
1757         byte[] r = fr.apply(SPECIES.length());
1758 
1759         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1760             for (int i = 0; i < a.length; i += SPECIES.length()) {
1761                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1762                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1763                 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1764             }
1765         }
1766 
1767         assertArraysEquals(r, a, b, ByteMaxVectorTests::FIRST_NONZERO);
1768     }
1769 
1770     @Test(dataProvider = "byteBinaryOpMaskProvider")
1771     static void FIRST_NONZEROByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1772                                           IntFunction<boolean[]> fm) {
1773         byte[] a = fa.apply(SPECIES.length());
1774         byte[] b = fb.apply(SPECIES.length());
1775         byte[] r = fr.apply(SPECIES.length());
1776         boolean[] mask = fm.apply(SPECIES.length());
1777         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1778 
1779         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1780             for (int i = 0; i < a.length; i += SPECIES.length()) {
1781                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1782                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1783                 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1784             }
1785         }
1786 
1787         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::FIRST_NONZERO);
1788     }
1789 
1790     static byte AND(byte a, byte b) {
1791         return (byte)(a & b);
1792     }
1793 
1794     @Test(dataProvider = "byteBinaryOpProvider")
1795     static void ANDByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1796         byte[] a = fa.apply(SPECIES.length());
1797         byte[] b = fb.apply(SPECIES.length());
1798         byte[] r = fr.apply(SPECIES.length());
1799 
1800         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1801             for (int i = 0; i < a.length; i += SPECIES.length()) {
1802                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1803                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1804                 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1805             }
1806         }
1807 
1808         assertArraysEquals(r, a, b, ByteMaxVectorTests::AND);
1809     }
1810 
1811     static byte and(byte a, byte b) {
1812         return (byte)(a & b);
1813     }
1814 
1815     @Test(dataProvider = "byteBinaryOpProvider")
1816     static void andByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1817         byte[] a = fa.apply(SPECIES.length());
1818         byte[] b = fb.apply(SPECIES.length());
1819         byte[] r = fr.apply(SPECIES.length());
1820 
1821         for (int i = 0; i < a.length; i += SPECIES.length()) {
1822             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1823             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1824             av.and(bv).intoArray(r, i);
1825         }
1826 
1827         assertArraysEquals(r, a, b, ByteMaxVectorTests::and);
1828     }
1829 
1830     @Test(dataProvider = "byteBinaryOpMaskProvider")
1831     static void ANDByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1832                                           IntFunction<boolean[]> fm) {
1833         byte[] a = fa.apply(SPECIES.length());
1834         byte[] b = fb.apply(SPECIES.length());
1835         byte[] r = fr.apply(SPECIES.length());
1836         boolean[] mask = fm.apply(SPECIES.length());
1837         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1838 
1839         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1840             for (int i = 0; i < a.length; i += SPECIES.length()) {
1841                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1842                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1843                 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1844             }
1845         }
1846 
1847         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::AND);
1848     }
1849 
1850     static byte AND_NOT(byte a, byte b) {
1851         return (byte)(a & ~b);
1852     }
1853 
1854     @Test(dataProvider = "byteBinaryOpProvider")
1855     static void AND_NOTByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1856         byte[] a = fa.apply(SPECIES.length());
1857         byte[] b = fb.apply(SPECIES.length());
1858         byte[] r = fr.apply(SPECIES.length());
1859 
1860         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1861             for (int i = 0; i < a.length; i += SPECIES.length()) {
1862                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1863                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1864                 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
1865             }
1866         }
1867 
1868         assertArraysEquals(r, a, b, ByteMaxVectorTests::AND_NOT);
1869     }
1870 
1871     @Test(dataProvider = "byteBinaryOpMaskProvider")
1872     static void AND_NOTByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1873                                           IntFunction<boolean[]> fm) {
1874         byte[] a = fa.apply(SPECIES.length());
1875         byte[] b = fb.apply(SPECIES.length());
1876         byte[] r = fr.apply(SPECIES.length());
1877         boolean[] mask = fm.apply(SPECIES.length());
1878         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1879 
1880         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1881             for (int i = 0; i < a.length; i += SPECIES.length()) {
1882                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1883                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1884                 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
1885             }
1886         }
1887 
1888         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::AND_NOT);
1889     }
1890 
1891     static byte OR(byte a, byte b) {
1892         return (byte)(a | b);
1893     }
1894 
1895     @Test(dataProvider = "byteBinaryOpProvider")
1896     static void ORByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1897         byte[] a = fa.apply(SPECIES.length());
1898         byte[] b = fb.apply(SPECIES.length());
1899         byte[] r = fr.apply(SPECIES.length());
1900 
1901         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1902             for (int i = 0; i < a.length; i += SPECIES.length()) {
1903                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1904                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1905                 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1906             }
1907         }
1908 
1909         assertArraysEquals(r, a, b, ByteMaxVectorTests::OR);
1910     }
1911 
1912     static byte or(byte a, byte b) {
1913         return (byte)(a | b);
1914     }
1915 
1916     @Test(dataProvider = "byteBinaryOpProvider")
1917     static void orByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1918         byte[] a = fa.apply(SPECIES.length());
1919         byte[] b = fb.apply(SPECIES.length());
1920         byte[] r = fr.apply(SPECIES.length());
1921 
1922         for (int i = 0; i < a.length; i += SPECIES.length()) {
1923             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1924             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1925             av.or(bv).intoArray(r, i);
1926         }
1927 
1928         assertArraysEquals(r, a, b, ByteMaxVectorTests::or);
1929     }
1930 
1931     @Test(dataProvider = "byteBinaryOpMaskProvider")
1932     static void ORByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1933                                           IntFunction<boolean[]> fm) {
1934         byte[] a = fa.apply(SPECIES.length());
1935         byte[] b = fb.apply(SPECIES.length());
1936         byte[] r = fr.apply(SPECIES.length());
1937         boolean[] mask = fm.apply(SPECIES.length());
1938         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1939 
1940         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1941             for (int i = 0; i < a.length; i += SPECIES.length()) {
1942                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1943                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1944                 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1945             }
1946         }
1947 
1948         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::OR);
1949     }
1950 
1951     static byte XOR(byte a, byte b) {
1952         return (byte)(a ^ b);
1953     }
1954 
1955     @Test(dataProvider = "byteBinaryOpProvider")
1956     static void XORByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1957         byte[] a = fa.apply(SPECIES.length());
1958         byte[] b = fb.apply(SPECIES.length());
1959         byte[] r = fr.apply(SPECIES.length());
1960 
1961         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1962             for (int i = 0; i < a.length; i += SPECIES.length()) {
1963                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1964                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1965                 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
1966             }
1967         }
1968 
1969         assertArraysEquals(r, a, b, ByteMaxVectorTests::XOR);
1970     }
1971 
1972     @Test(dataProvider = "byteBinaryOpMaskProvider")
1973     static void XORByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
1974                                           IntFunction<boolean[]> fm) {
1975         byte[] a = fa.apply(SPECIES.length());
1976         byte[] b = fb.apply(SPECIES.length());
1977         byte[] r = fr.apply(SPECIES.length());
1978         boolean[] mask = fm.apply(SPECIES.length());
1979         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1980 
1981         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1982             for (int i = 0; i < a.length; i += SPECIES.length()) {
1983                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
1984                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
1985                 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1986             }
1987         }
1988 
1989         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::XOR);
1990     }
1991 
1992     @Test(dataProvider = "byteBinaryOpProvider")
1993     static void addByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
1994         byte[] a = fa.apply(SPECIES.length());
1995         byte[] b = fb.apply(SPECIES.length());
1996         byte[] r = fr.apply(SPECIES.length());
1997 
1998         for (int i = 0; i < a.length; i += SPECIES.length()) {
1999             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2000             av.add(b[i]).intoArray(r, i);
2001         }
2002 
2003         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::add);
2004     }
2005 
2006     @Test(dataProvider = "byteBinaryOpMaskProvider")
2007     static void addByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2008                                           IntFunction<boolean[]> fm) {
2009         byte[] a = fa.apply(SPECIES.length());
2010         byte[] b = fb.apply(SPECIES.length());
2011         byte[] r = fr.apply(SPECIES.length());
2012         boolean[] mask = fm.apply(SPECIES.length());
2013         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2014 
2015         for (int i = 0; i < a.length; i += SPECIES.length()) {
2016             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2017             av.add(b[i], vmask).intoArray(r, i);
2018         }
2019 
2020         assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::add);
2021     }
2022 
2023     @Test(dataProvider = "byteBinaryOpProvider")
2024     static void subByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2025         byte[] a = fa.apply(SPECIES.length());
2026         byte[] b = fb.apply(SPECIES.length());
2027         byte[] r = fr.apply(SPECIES.length());
2028 
2029         for (int i = 0; i < a.length; i += SPECIES.length()) {
2030             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2031             av.sub(b[i]).intoArray(r, i);
2032         }
2033 
2034         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::sub);
2035     }
2036 
2037     @Test(dataProvider = "byteBinaryOpMaskProvider")
2038     static void subByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2039                                           IntFunction<boolean[]> fm) {
2040         byte[] a = fa.apply(SPECIES.length());
2041         byte[] b = fb.apply(SPECIES.length());
2042         byte[] r = fr.apply(SPECIES.length());
2043         boolean[] mask = fm.apply(SPECIES.length());
2044         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2045 
2046         for (int i = 0; i < a.length; i += SPECIES.length()) {
2047             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2048             av.sub(b[i], vmask).intoArray(r, i);
2049         }
2050 
2051         assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::sub);
2052     }
2053 
2054     @Test(dataProvider = "byteBinaryOpProvider")
2055     static void mulByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2056         byte[] a = fa.apply(SPECIES.length());
2057         byte[] b = fb.apply(SPECIES.length());
2058         byte[] r = fr.apply(SPECIES.length());
2059 
2060         for (int i = 0; i < a.length; i += SPECIES.length()) {
2061             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2062             av.mul(b[i]).intoArray(r, i);
2063         }
2064 
2065         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::mul);
2066     }
2067 
2068     @Test(dataProvider = "byteBinaryOpMaskProvider")
2069     static void mulByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2070                                           IntFunction<boolean[]> fm) {
2071         byte[] a = fa.apply(SPECIES.length());
2072         byte[] b = fb.apply(SPECIES.length());
2073         byte[] r = fr.apply(SPECIES.length());
2074         boolean[] mask = fm.apply(SPECIES.length());
2075         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2076 
2077         for (int i = 0; i < a.length; i += SPECIES.length()) {
2078             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2079             av.mul(b[i], vmask).intoArray(r, i);
2080         }
2081 
2082         assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::mul);
2083     }
2084 
2085     @Test(dataProvider = "byteBinaryOpProvider")
2086     static void divByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2087         byte[] a = fa.apply(SPECIES.length());
2088         byte[] b = fb.apply(SPECIES.length());
2089         byte[] r = fr.apply(SPECIES.length());
2090 
2091         replaceZero(b, (byte) 1);
2092 
2093         for (int i = 0; i < a.length; i += SPECIES.length()) {
2094             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2095             av.div(b[i]).intoArray(r, i);
2096         }
2097 
2098         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::div);
2099     }
2100 
2101     @Test(dataProvider = "byteBinaryOpMaskProvider")
2102     static void divByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2103                                           IntFunction<boolean[]> fm) {
2104         byte[] a = fa.apply(SPECIES.length());
2105         byte[] b = fb.apply(SPECIES.length());
2106         byte[] r = fr.apply(SPECIES.length());
2107         boolean[] mask = fm.apply(SPECIES.length());
2108         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2109 
2110         replaceZero(b, (byte) 1);
2111 
2112         for (int i = 0; i < a.length; i += SPECIES.length()) {
2113             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2114             av.div(b[i], vmask).intoArray(r, i);
2115         }
2116 
2117         assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::div);
2118     }
2119 
2120     @Test(dataProvider = "byteBinaryOpProvider")
2121     static void ORByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2122         byte[] a = fa.apply(SPECIES.length());
2123         byte[] b = fb.apply(SPECIES.length());
2124         byte[] r = fr.apply(SPECIES.length());
2125 
2126         for (int i = 0; i < a.length; i += SPECIES.length()) {
2127             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2128             av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
2129         }
2130 
2131         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::OR);
2132     }
2133 
2134     @Test(dataProvider = "byteBinaryOpProvider")
2135     static void orByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2136         byte[] a = fa.apply(SPECIES.length());
2137         byte[] b = fb.apply(SPECIES.length());
2138         byte[] r = fr.apply(SPECIES.length());
2139 
2140         for (int i = 0; i < a.length; i += SPECIES.length()) {
2141             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2142             av.or(b[i]).intoArray(r, i);
2143         }
2144 
2145         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::or);
2146     }
2147 
2148     @Test(dataProvider = "byteBinaryOpMaskProvider")
2149     static void ORByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2150                                           IntFunction<boolean[]> fm) {
2151         byte[] a = fa.apply(SPECIES.length());
2152         byte[] b = fb.apply(SPECIES.length());
2153         byte[] r = fr.apply(SPECIES.length());
2154         boolean[] mask = fm.apply(SPECIES.length());
2155         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2156 
2157         for (int i = 0; i < a.length; i += SPECIES.length()) {
2158             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2159             av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
2160         }
2161 
2162         assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::OR);
2163     }
2164 
2165     @Test(dataProvider = "byteBinaryOpProvider")
2166     static void ANDByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2167         byte[] a = fa.apply(SPECIES.length());
2168         byte[] b = fb.apply(SPECIES.length());
2169         byte[] r = fr.apply(SPECIES.length());
2170 
2171         for (int i = 0; i < a.length; i += SPECIES.length()) {
2172             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2173             av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
2174         }
2175 
2176         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::AND);
2177     }
2178 
2179     @Test(dataProvider = "byteBinaryOpProvider")
2180     static void andByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2181         byte[] a = fa.apply(SPECIES.length());
2182         byte[] b = fb.apply(SPECIES.length());
2183         byte[] r = fr.apply(SPECIES.length());
2184 
2185         for (int i = 0; i < a.length; i += SPECIES.length()) {
2186             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2187             av.and(b[i]).intoArray(r, i);
2188         }
2189 
2190         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::and);
2191     }
2192 
2193     @Test(dataProvider = "byteBinaryOpMaskProvider")
2194     static void ANDByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2195                                           IntFunction<boolean[]> fm) {
2196         byte[] a = fa.apply(SPECIES.length());
2197         byte[] b = fb.apply(SPECIES.length());
2198         byte[] r = fr.apply(SPECIES.length());
2199         boolean[] mask = fm.apply(SPECIES.length());
2200         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2201 
2202         for (int i = 0; i < a.length; i += SPECIES.length()) {
2203             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2204             av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
2205         }
2206 
2207         assertBroadcastArraysEquals(r, a, b, mask, ByteMaxVectorTests::AND);
2208     }
2209 
2210     @Test(dataProvider = "byteBinaryOpProvider")
2211     static void ORByteMaxVectorTestsBroadcastLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2212         byte[] a = fa.apply(SPECIES.length());
2213         byte[] b = fb.apply(SPECIES.length());
2214         byte[] r = fr.apply(SPECIES.length());
2215 
2216         for (int i = 0; i < a.length; i += SPECIES.length()) {
2217             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2218             av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
2219         }
2220 
2221         assertBroadcastLongArraysEquals(r, a, b, ByteMaxVectorTests::OR);
2222     }
2223 
2224     @Test(dataProvider = "byteBinaryOpMaskProvider")
2225     static void ORByteMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2226                                           IntFunction<boolean[]> fm) {
2227         byte[] a = fa.apply(SPECIES.length());
2228         byte[] b = fb.apply(SPECIES.length());
2229         byte[] r = fr.apply(SPECIES.length());
2230         boolean[] mask = fm.apply(SPECIES.length());
2231         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2232 
2233         for (int i = 0; i < a.length; i += SPECIES.length()) {
2234             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2235             av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
2236         }
2237 
2238         assertBroadcastLongArraysEquals(r, a, b, mask, ByteMaxVectorTests::OR);
2239     }
2240 
2241     @Test(dataProvider = "byteBinaryOpProvider")
2242     static void ADDByteMaxVectorTestsBroadcastLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2243         byte[] a = fa.apply(SPECIES.length());
2244         byte[] b = fb.apply(SPECIES.length());
2245         byte[] r = fr.apply(SPECIES.length());
2246 
2247         for (int i = 0; i < a.length; i += SPECIES.length()) {
2248             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2249             av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2250         }
2251 
2252         assertBroadcastLongArraysEquals(r, a, b, ByteMaxVectorTests::ADD);
2253     }
2254 
2255     @Test(dataProvider = "byteBinaryOpMaskProvider")
2256     static void ADDByteMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2257                                           IntFunction<boolean[]> fm) {
2258         byte[] a = fa.apply(SPECIES.length());
2259         byte[] b = fb.apply(SPECIES.length());
2260         byte[] r = fr.apply(SPECIES.length());
2261         boolean[] mask = fm.apply(SPECIES.length());
2262         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2263 
2264         for (int i = 0; i < a.length; i += SPECIES.length()) {
2265             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2266             av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2267         }
2268 
2269         assertBroadcastLongArraysEquals(r, a, b, mask, ByteMaxVectorTests::ADD);
2270     }
2271 
2272     static byte LSHL(byte a, byte b) {
2273         return (byte)((a << (b & 0x7)));
2274     }
2275 
2276     @Test(dataProvider = "byteBinaryOpProvider")
2277     static void LSHLByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2278         byte[] a = fa.apply(SPECIES.length());
2279         byte[] b = fb.apply(SPECIES.length());
2280         byte[] r = fr.apply(SPECIES.length());
2281 
2282         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2283             for (int i = 0; i < a.length; i += SPECIES.length()) {
2284                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2285                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2286                 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
2287             }
2288         }
2289 
2290         assertArraysEquals(r, a, b, ByteMaxVectorTests::LSHL);
2291     }
2292 
2293     @Test(dataProvider = "byteBinaryOpMaskProvider")
2294     static void LSHLByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2295                                           IntFunction<boolean[]> fm) {
2296         byte[] a = fa.apply(SPECIES.length());
2297         byte[] b = fb.apply(SPECIES.length());
2298         byte[] r = fr.apply(SPECIES.length());
2299         boolean[] mask = fm.apply(SPECIES.length());
2300         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2301 
2302         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2303             for (int i = 0; i < a.length; i += SPECIES.length()) {
2304                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2305                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2306                 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
2307             }
2308         }
2309 
2310         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::LSHL);
2311     }
2312 
2313     static byte ASHR(byte a, byte b) {
2314         return (byte)((a >> (b & 0x7)));
2315     }
2316 
2317     @Test(dataProvider = "byteBinaryOpProvider")
2318     static void ASHRByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2319         byte[] a = fa.apply(SPECIES.length());
2320         byte[] b = fb.apply(SPECIES.length());
2321         byte[] r = fr.apply(SPECIES.length());
2322 
2323         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2324             for (int i = 0; i < a.length; i += SPECIES.length()) {
2325                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2326                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2327                 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
2328             }
2329         }
2330 
2331         assertArraysEquals(r, a, b, ByteMaxVectorTests::ASHR);
2332     }
2333 
2334     @Test(dataProvider = "byteBinaryOpMaskProvider")
2335     static void ASHRByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2336                                           IntFunction<boolean[]> fm) {
2337         byte[] a = fa.apply(SPECIES.length());
2338         byte[] b = fb.apply(SPECIES.length());
2339         byte[] r = fr.apply(SPECIES.length());
2340         boolean[] mask = fm.apply(SPECIES.length());
2341         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2342 
2343         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2344             for (int i = 0; i < a.length; i += SPECIES.length()) {
2345                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2346                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2347                 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
2348             }
2349         }
2350 
2351         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::ASHR);
2352     }
2353 
2354     static byte LSHR(byte a, byte b) {
2355         return (byte)(((a & 0xFF) >>> (b & 0x7)));
2356     }
2357 
2358     @Test(dataProvider = "byteBinaryOpProvider")
2359     static void LSHRByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2360         byte[] a = fa.apply(SPECIES.length());
2361         byte[] b = fb.apply(SPECIES.length());
2362         byte[] r = fr.apply(SPECIES.length());
2363 
2364         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2365             for (int i = 0; i < a.length; i += SPECIES.length()) {
2366                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2367                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2368                 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
2369             }
2370         }
2371 
2372         assertArraysEquals(r, a, b, ByteMaxVectorTests::LSHR);
2373     }
2374 
2375     @Test(dataProvider = "byteBinaryOpMaskProvider")
2376     static void LSHRByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2377                                           IntFunction<boolean[]> fm) {
2378         byte[] a = fa.apply(SPECIES.length());
2379         byte[] b = fb.apply(SPECIES.length());
2380         byte[] r = fr.apply(SPECIES.length());
2381         boolean[] mask = fm.apply(SPECIES.length());
2382         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2383 
2384         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2385             for (int i = 0; i < a.length; i += SPECIES.length()) {
2386                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2387                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2388                 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
2389             }
2390         }
2391 
2392         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::LSHR);
2393     }
2394 
2395     static byte LSHL_unary(byte a, byte b) {
2396         return (byte)((a << (b & 7)));
2397     }
2398 
2399     @Test(dataProvider = "byteBinaryOpProvider")
2400     static void LSHLByteMaxVectorTestsScalarShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2401         byte[] a = fa.apply(SPECIES.length());
2402         byte[] b = fb.apply(SPECIES.length());
2403         byte[] r = fr.apply(SPECIES.length());
2404 
2405         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2406             for (int i = 0; i < a.length; i += SPECIES.length()) {
2407                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2408                 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
2409             }
2410         }
2411 
2412         assertShiftArraysEquals(r, a, b, ByteMaxVectorTests::LSHL_unary);
2413     }
2414 
2415     @Test(dataProvider = "byteBinaryOpMaskProvider")
2416     static void LSHLByteMaxVectorTestsScalarShiftMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2417                                           IntFunction<boolean[]> fm) {
2418         byte[] a = fa.apply(SPECIES.length());
2419         byte[] b = fb.apply(SPECIES.length());
2420         byte[] r = fr.apply(SPECIES.length());
2421         boolean[] mask = fm.apply(SPECIES.length());
2422         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2423 
2424         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2425             for (int i = 0; i < a.length; i += SPECIES.length()) {
2426                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2427                 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
2428             }
2429         }
2430 
2431         assertShiftArraysEquals(r, a, b, mask, ByteMaxVectorTests::LSHL_unary);
2432     }
2433 
2434     static byte LSHR_unary(byte a, byte b) {
2435         return (byte)(((a & 0xFF) >>> (b & 7)));
2436     }
2437 
2438     @Test(dataProvider = "byteBinaryOpProvider")
2439     static void LSHRByteMaxVectorTestsScalarShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2440         byte[] a = fa.apply(SPECIES.length());
2441         byte[] b = fb.apply(SPECIES.length());
2442         byte[] r = fr.apply(SPECIES.length());
2443 
2444         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2445             for (int i = 0; i < a.length; i += SPECIES.length()) {
2446                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2447                 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
2448             }
2449         }
2450 
2451         assertShiftArraysEquals(r, a, b, ByteMaxVectorTests::LSHR_unary);
2452     }
2453 
2454     @Test(dataProvider = "byteBinaryOpMaskProvider")
2455     static void LSHRByteMaxVectorTestsScalarShiftMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2456                                           IntFunction<boolean[]> fm) {
2457         byte[] a = fa.apply(SPECIES.length());
2458         byte[] b = fb.apply(SPECIES.length());
2459         byte[] r = fr.apply(SPECIES.length());
2460         boolean[] mask = fm.apply(SPECIES.length());
2461         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2462 
2463         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2464             for (int i = 0; i < a.length; i += SPECIES.length()) {
2465                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2466                 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
2467             }
2468         }
2469 
2470         assertShiftArraysEquals(r, a, b, mask, ByteMaxVectorTests::LSHR_unary);
2471     }
2472 
2473     static byte ASHR_unary(byte a, byte b) {
2474         return (byte)((a >> (b & 7)));
2475     }
2476 
2477     @Test(dataProvider = "byteBinaryOpProvider")
2478     static void ASHRByteMaxVectorTestsScalarShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2479         byte[] a = fa.apply(SPECIES.length());
2480         byte[] b = fb.apply(SPECIES.length());
2481         byte[] r = fr.apply(SPECIES.length());
2482 
2483         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2484             for (int i = 0; i < a.length; i += SPECIES.length()) {
2485                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2486                 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
2487             }
2488         }
2489 
2490         assertShiftArraysEquals(r, a, b, ByteMaxVectorTests::ASHR_unary);
2491     }
2492 
2493     @Test(dataProvider = "byteBinaryOpMaskProvider")
2494     static void ASHRByteMaxVectorTestsScalarShiftMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2495                                           IntFunction<boolean[]> fm) {
2496         byte[] a = fa.apply(SPECIES.length());
2497         byte[] b = fb.apply(SPECIES.length());
2498         byte[] r = fr.apply(SPECIES.length());
2499         boolean[] mask = fm.apply(SPECIES.length());
2500         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2501 
2502         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2503             for (int i = 0; i < a.length; i += SPECIES.length()) {
2504                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2505                 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
2506             }
2507         }
2508 
2509         assertShiftArraysEquals(r, a, b, mask, ByteMaxVectorTests::ASHR_unary);
2510     }
2511 
2512     static byte ROR(byte a, byte b) {
2513         return (byte)(ROR_scalar(a,b));
2514     }
2515 
2516     @Test(dataProvider = "byteBinaryOpProvider")
2517     static void RORByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2518         byte[] a = fa.apply(SPECIES.length());
2519         byte[] b = fb.apply(SPECIES.length());
2520         byte[] r = fr.apply(SPECIES.length());
2521 
2522         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2523             for (int i = 0; i < a.length; i += SPECIES.length()) {
2524                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2525                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2526                 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
2527             }
2528         }
2529 
2530         assertArraysEquals(r, a, b, ByteMaxVectorTests::ROR);
2531     }
2532 
2533     @Test(dataProvider = "byteBinaryOpMaskProvider")
2534     static void RORByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2535                                           IntFunction<boolean[]> fm) {
2536         byte[] a = fa.apply(SPECIES.length());
2537         byte[] b = fb.apply(SPECIES.length());
2538         byte[] r = fr.apply(SPECIES.length());
2539         boolean[] mask = fm.apply(SPECIES.length());
2540         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2541 
2542         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2543             for (int i = 0; i < a.length; i += SPECIES.length()) {
2544                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2545                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2546                 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
2547             }
2548         }
2549 
2550         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::ROR);
2551     }
2552 
2553     static byte ROL(byte a, byte b) {
2554         return (byte)(ROL_scalar(a,b));
2555     }
2556 
2557     @Test(dataProvider = "byteBinaryOpProvider")
2558     static void ROLByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2559         byte[] a = fa.apply(SPECIES.length());
2560         byte[] b = fb.apply(SPECIES.length());
2561         byte[] 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                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2566                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2567                 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
2568             }
2569         }
2570 
2571         assertArraysEquals(r, a, b, ByteMaxVectorTests::ROL);
2572     }
2573 
2574     @Test(dataProvider = "byteBinaryOpMaskProvider")
2575     static void ROLByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2576                                           IntFunction<boolean[]> fm) {
2577         byte[] a = fa.apply(SPECIES.length());
2578         byte[] b = fb.apply(SPECIES.length());
2579         byte[] r = fr.apply(SPECIES.length());
2580         boolean[] mask = fm.apply(SPECIES.length());
2581         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2582 
2583         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2584             for (int i = 0; i < a.length; i += SPECIES.length()) {
2585                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2586                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2587                 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
2588             }
2589         }
2590 
2591         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::ROL);
2592     }
2593 
2594     static byte ROR_unary(byte a, byte b) {
2595         return (byte)(ROR_scalar(a, b));
2596     }
2597 
2598     @Test(dataProvider = "byteBinaryOpProvider")
2599     static void RORByteMaxVectorTestsScalarShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2600         byte[] a = fa.apply(SPECIES.length());
2601         byte[] b = fb.apply(SPECIES.length());
2602         byte[] r = fr.apply(SPECIES.length());
2603 
2604         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2605             for (int i = 0; i < a.length; i += SPECIES.length()) {
2606                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2607                 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
2608             }
2609         }
2610 
2611         assertShiftArraysEquals(r, a, b, ByteMaxVectorTests::ROR_unary);
2612     }
2613 
2614     @Test(dataProvider = "byteBinaryOpMaskProvider")
2615     static void RORByteMaxVectorTestsScalarShiftMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2616                                           IntFunction<boolean[]> fm) {
2617         byte[] a = fa.apply(SPECIES.length());
2618         byte[] b = fb.apply(SPECIES.length());
2619         byte[] r = fr.apply(SPECIES.length());
2620         boolean[] mask = fm.apply(SPECIES.length());
2621         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2622 
2623         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2624             for (int i = 0; i < a.length; i += SPECIES.length()) {
2625                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2626                 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
2627             }
2628         }
2629 
2630         assertShiftArraysEquals(r, a, b, mask, ByteMaxVectorTests::ROR_unary);
2631     }
2632 
2633     static byte ROL_unary(byte a, byte b) {
2634         return (byte)(ROL_scalar(a, b));
2635     }
2636 
2637     @Test(dataProvider = "byteBinaryOpProvider")
2638     static void ROLByteMaxVectorTestsScalarShift(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2639         byte[] a = fa.apply(SPECIES.length());
2640         byte[] b = fb.apply(SPECIES.length());
2641         byte[] r = fr.apply(SPECIES.length());
2642 
2643         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2644             for (int i = 0; i < a.length; i += SPECIES.length()) {
2645                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2646                 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
2647             }
2648         }
2649 
2650         assertShiftArraysEquals(r, a, b, ByteMaxVectorTests::ROL_unary);
2651     }
2652 
2653     @Test(dataProvider = "byteBinaryOpMaskProvider")
2654     static void ROLByteMaxVectorTestsScalarShiftMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
2655                                           IntFunction<boolean[]> fm) {
2656         byte[] a = fa.apply(SPECIES.length());
2657         byte[] b = fb.apply(SPECIES.length());
2658         byte[] r = fr.apply(SPECIES.length());
2659         boolean[] mask = fm.apply(SPECIES.length());
2660         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2661 
2662         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2663             for (int i = 0; i < a.length; i += SPECIES.length()) {
2664                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2665                 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
2666             }
2667         }
2668 
2669         assertShiftArraysEquals(r, a, b, mask, ByteMaxVectorTests::ROL_unary);
2670     }
2671     static byte LSHR_binary_const(byte a) {
2672         return (byte)(((a & 0xFF) >>> CONST_SHIFT));
2673     }
2674 
2675     @Test(dataProvider = "byteUnaryOpProvider")
2676     static void LSHRByteMaxVectorTestsScalarShiftConst(IntFunction<byte[]> fa) {
2677         byte[] a = fa.apply(SPECIES.length());
2678         byte[] r = fr.apply(SPECIES.length());
2679 
2680         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2681             for (int i = 0; i < a.length; i += SPECIES.length()) {
2682                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2683                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i);
2684             }
2685         }
2686 
2687         assertShiftConstEquals(r, a, ByteMaxVectorTests::LSHR_binary_const);
2688     }
2689 
2690     @Test(dataProvider = "byteUnaryOpMaskProvider")
2691     static void LSHRByteMaxVectorTestsScalarShiftMaskedConst(IntFunction<byte[]> fa,
2692                                           IntFunction<boolean[]> fm) {
2693         byte[] a = fa.apply(SPECIES.length());
2694         byte[] r = fr.apply(SPECIES.length());
2695         boolean[] mask = fm.apply(SPECIES.length());
2696         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2697 
2698         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2699             for (int i = 0; i < a.length; i += SPECIES.length()) {
2700                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2701                 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i);
2702             }
2703         }
2704 
2705         assertShiftConstEquals(r, a, mask, ByteMaxVectorTests::LSHR_binary_const);
2706     }
2707 
2708     static byte LSHL_binary_const(byte a) {
2709         return (byte)((a << CONST_SHIFT));
2710     }
2711 
2712     @Test(dataProvider = "byteUnaryOpProvider")
2713     static void LSHLByteMaxVectorTestsScalarShiftConst(IntFunction<byte[]> fa) {
2714         byte[] a = fa.apply(SPECIES.length());
2715         byte[] r = fr.apply(SPECIES.length());
2716 
2717         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2718             for (int i = 0; i < a.length; i += SPECIES.length()) {
2719                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2720                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i);
2721             }
2722         }
2723 
2724         assertShiftConstEquals(r, a, ByteMaxVectorTests::LSHL_binary_const);
2725     }
2726 
2727     @Test(dataProvider = "byteUnaryOpMaskProvider")
2728     static void LSHLByteMaxVectorTestsScalarShiftMaskedConst(IntFunction<byte[]> fa,
2729                                           IntFunction<boolean[]> fm) {
2730         byte[] a = fa.apply(SPECIES.length());
2731         byte[] r = fr.apply(SPECIES.length());
2732         boolean[] mask = fm.apply(SPECIES.length());
2733         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2734 
2735         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2736             for (int i = 0; i < a.length; i += SPECIES.length()) {
2737                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2738                 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i);
2739             }
2740         }
2741 
2742         assertShiftConstEquals(r, a, mask, ByteMaxVectorTests::LSHL_binary_const);
2743     }
2744 
2745     static byte ASHR_binary_const(byte a) {
2746         return (byte)((a >> CONST_SHIFT));
2747     }
2748 
2749     @Test(dataProvider = "byteUnaryOpProvider")
2750     static void ASHRByteMaxVectorTestsScalarShiftConst(IntFunction<byte[]> fa) {
2751         byte[] a = fa.apply(SPECIES.length());
2752         byte[] r = fr.apply(SPECIES.length());
2753 
2754         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2755             for (int i = 0; i < a.length; i += SPECIES.length()) {
2756                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2757                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i);
2758             }
2759         }
2760 
2761         assertShiftConstEquals(r, a, ByteMaxVectorTests::ASHR_binary_const);
2762     }
2763 
2764     @Test(dataProvider = "byteUnaryOpMaskProvider")
2765     static void ASHRByteMaxVectorTestsScalarShiftMaskedConst(IntFunction<byte[]> fa,
2766                                           IntFunction<boolean[]> fm) {
2767         byte[] a = fa.apply(SPECIES.length());
2768         byte[] r = fr.apply(SPECIES.length());
2769         boolean[] mask = fm.apply(SPECIES.length());
2770         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2771 
2772         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2773             for (int i = 0; i < a.length; i += SPECIES.length()) {
2774                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2775                 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i);
2776             }
2777         }
2778 
2779         assertShiftConstEquals(r, a, mask, ByteMaxVectorTests::ASHR_binary_const);
2780     }
2781 
2782     static byte ROR_binary_const(byte a) {
2783         return (byte)(ROR_scalar(a, CONST_SHIFT));
2784     }
2785 
2786     @Test(dataProvider = "byteUnaryOpProvider")
2787     static void RORByteMaxVectorTestsScalarShiftConst(IntFunction<byte[]> fa) {
2788         byte[] a = fa.apply(SPECIES.length());
2789         byte[] r = fr.apply(SPECIES.length());
2790 
2791         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2792             for (int i = 0; i < a.length; i += SPECIES.length()) {
2793                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2794                 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i);
2795             }
2796         }
2797 
2798         assertShiftConstEquals(r, a, ByteMaxVectorTests::ROR_binary_const);
2799     }
2800 
2801     @Test(dataProvider = "byteUnaryOpMaskProvider")
2802     static void RORByteMaxVectorTestsScalarShiftMaskedConst(IntFunction<byte[]> fa,
2803                                           IntFunction<boolean[]> fm) {
2804         byte[] a = fa.apply(SPECIES.length());
2805         byte[] r = fr.apply(SPECIES.length());
2806         boolean[] mask = fm.apply(SPECIES.length());
2807         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2808 
2809         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2810             for (int i = 0; i < a.length; i += SPECIES.length()) {
2811                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2812                 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i);
2813             }
2814         }
2815 
2816         assertShiftConstEquals(r, a, mask, ByteMaxVectorTests::ROR_binary_const);
2817     }
2818 
2819     static byte ROL_binary_const(byte a) {
2820         return (byte)(ROL_scalar(a, CONST_SHIFT));
2821     }
2822 
2823     @Test(dataProvider = "byteUnaryOpProvider")
2824     static void ROLByteMaxVectorTestsScalarShiftConst(IntFunction<byte[]> fa) {
2825         byte[] a = fa.apply(SPECIES.length());
2826         byte[] r = fr.apply(SPECIES.length());
2827 
2828         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2829             for (int i = 0; i < a.length; i += SPECIES.length()) {
2830                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2831                 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i);
2832             }
2833         }
2834 
2835         assertShiftConstEquals(r, a, ByteMaxVectorTests::ROL_binary_const);
2836     }
2837 
2838     @Test(dataProvider = "byteUnaryOpMaskProvider")
2839     static void ROLByteMaxVectorTestsScalarShiftMaskedConst(IntFunction<byte[]> fa,
2840                                           IntFunction<boolean[]> fm) {
2841         byte[] a = fa.apply(SPECIES.length());
2842         byte[] r = fr.apply(SPECIES.length());
2843         boolean[] mask = fm.apply(SPECIES.length());
2844         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2845 
2846         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2847             for (int i = 0; i < a.length; i += SPECIES.length()) {
2848                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2849                 av.lanewise(VectorOperators.ROL, CONST_SHIFT, vmask).intoArray(r, i);
2850             }
2851         }
2852 
2853         assertShiftConstEquals(r, a, mask, ByteMaxVectorTests::ROL_binary_const);
2854     }
2855 
2856 
2857     static byte MIN(byte a, byte b) {
2858         return (byte)(Math.min(a, b));
2859     }
2860 
2861     @Test(dataProvider = "byteBinaryOpProvider")
2862     static void MINByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2863         byte[] a = fa.apply(SPECIES.length());
2864         byte[] b = fb.apply(SPECIES.length());
2865         byte[] r = fr.apply(SPECIES.length());
2866 
2867         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2868             for (int i = 0; i < a.length; i += SPECIES.length()) {
2869                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2870                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2871                 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
2872             }
2873         }
2874 
2875         assertArraysEquals(r, a, b, ByteMaxVectorTests::MIN);
2876     }
2877 
2878     static byte min(byte a, byte b) {
2879         return (byte)(Math.min(a, b));
2880     }
2881 
2882     @Test(dataProvider = "byteBinaryOpProvider")
2883     static void minByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2884         byte[] a = fa.apply(SPECIES.length());
2885         byte[] b = fb.apply(SPECIES.length());
2886         byte[] r = fr.apply(SPECIES.length());
2887 
2888         for (int i = 0; i < a.length; i += SPECIES.length()) {
2889             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2890             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2891             av.min(bv).intoArray(r, i);
2892         }
2893 
2894         assertArraysEquals(r, a, b, ByteMaxVectorTests::min);
2895     }
2896 
2897     static byte MAX(byte a, byte b) {
2898         return (byte)(Math.max(a, b));
2899     }
2900 
2901     @Test(dataProvider = "byteBinaryOpProvider")
2902     static void MAXByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2903         byte[] a = fa.apply(SPECIES.length());
2904         byte[] b = fb.apply(SPECIES.length());
2905         byte[] r = fr.apply(SPECIES.length());
2906 
2907         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2908             for (int i = 0; i < a.length; i += SPECIES.length()) {
2909                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2910                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2911                 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
2912             }
2913         }
2914 
2915         assertArraysEquals(r, a, b, ByteMaxVectorTests::MAX);
2916     }
2917 
2918     static byte max(byte a, byte b) {
2919         return (byte)(Math.max(a, b));
2920     }
2921 
2922     @Test(dataProvider = "byteBinaryOpProvider")
2923     static void maxByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2924         byte[] a = fa.apply(SPECIES.length());
2925         byte[] b = fb.apply(SPECIES.length());
2926         byte[] r = fr.apply(SPECIES.length());
2927 
2928         for (int i = 0; i < a.length; i += SPECIES.length()) {
2929             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2930             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
2931             av.max(bv).intoArray(r, i);
2932         }
2933 
2934         assertArraysEquals(r, a, b, ByteMaxVectorTests::max);
2935     }
2936 
2937     @Test(dataProvider = "byteBinaryOpProvider")
2938     static void MINByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2939         byte[] a = fa.apply(SPECIES.length());
2940         byte[] b = fb.apply(SPECIES.length());
2941         byte[] r = fr.apply(SPECIES.length());
2942 
2943         for (int i = 0; i < a.length; i += SPECIES.length()) {
2944             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2945             av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
2946         }
2947 
2948         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::MIN);
2949     }
2950 
2951     @Test(dataProvider = "byteBinaryOpProvider")
2952     static void minByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2953         byte[] a = fa.apply(SPECIES.length());
2954         byte[] b = fb.apply(SPECIES.length());
2955         byte[] r = fr.apply(SPECIES.length());
2956 
2957         for (int i = 0; i < a.length; i += SPECIES.length()) {
2958             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2959             av.min(b[i]).intoArray(r, i);
2960         }
2961 
2962         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::min);
2963     }
2964 
2965     @Test(dataProvider = "byteBinaryOpProvider")
2966     static void MAXByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2967         byte[] a = fa.apply(SPECIES.length());
2968         byte[] b = fb.apply(SPECIES.length());
2969         byte[] r = fr.apply(SPECIES.length());
2970 
2971         for (int i = 0; i < a.length; i += SPECIES.length()) {
2972             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2973             av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
2974         }
2975 
2976         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::MAX);
2977     }
2978 
2979     @Test(dataProvider = "byteBinaryOpProvider")
2980     static void maxByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
2981         byte[] a = fa.apply(SPECIES.length());
2982         byte[] b = fb.apply(SPECIES.length());
2983         byte[] r = fr.apply(SPECIES.length());
2984 
2985         for (int i = 0; i < a.length; i += SPECIES.length()) {
2986             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
2987             av.max(b[i]).intoArray(r, i);
2988         }
2989 
2990         assertBroadcastArraysEquals(r, a, b, ByteMaxVectorTests::max);
2991     }
2992 
2993     static byte ANDReduce(byte[] a, int idx) {
2994         byte res = -1;
2995         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2996             res &= a[i];
2997         }
2998 
2999         return res;
3000     }
3001 
3002     static byte ANDReduceAll(byte[] a) {
3003         byte res = -1;
3004         for (int i = 0; i < a.length; i += SPECIES.length()) {
3005             res &= ANDReduce(a, i);
3006         }
3007 
3008         return res;
3009     }
3010 
3011     @Test(dataProvider = "byteUnaryOpProvider")
3012     static void ANDReduceByteMaxVectorTests(IntFunction<byte[]> fa) {
3013         byte[] a = fa.apply(SPECIES.length());
3014         byte[] r = fr.apply(SPECIES.length());
3015         byte ra = -1;
3016 
3017         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3018             for (int i = 0; i < a.length; i += SPECIES.length()) {
3019                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3020                 r[i] = av.reduceLanes(VectorOperators.AND);
3021             }
3022         }
3023 
3024         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3025             ra = -1;
3026             for (int i = 0; i < a.length; i += SPECIES.length()) {
3027                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3028                 ra &= av.reduceLanes(VectorOperators.AND);
3029             }
3030         }
3031 
3032         assertReductionArraysEquals(r, ra, a,
3033                 ByteMaxVectorTests::ANDReduce, ByteMaxVectorTests::ANDReduceAll);
3034     }
3035 
3036     static byte ANDReduceMasked(byte[] a, int idx, boolean[] mask) {
3037         byte res = -1;
3038         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3039             if (mask[i % SPECIES.length()])
3040                 res &= a[i];
3041         }
3042 
3043         return res;
3044     }
3045 
3046     static byte ANDReduceAllMasked(byte[] a, boolean[] mask) {
3047         byte res = -1;
3048         for (int i = 0; i < a.length; i += SPECIES.length()) {
3049             res &= ANDReduceMasked(a, i, mask);
3050         }
3051 
3052         return res;
3053     }
3054 
3055     @Test(dataProvider = "byteUnaryOpMaskProvider")
3056     static void ANDReduceByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
3057         byte[] a = fa.apply(SPECIES.length());
3058         byte[] r = fr.apply(SPECIES.length());
3059         boolean[] mask = fm.apply(SPECIES.length());
3060         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3061         byte ra = -1;
3062 
3063         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3064             for (int i = 0; i < a.length; i += SPECIES.length()) {
3065                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3066                 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
3067             }
3068         }
3069 
3070         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3071             ra = -1;
3072             for (int i = 0; i < a.length; i += SPECIES.length()) {
3073                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3074                 ra &= av.reduceLanes(VectorOperators.AND, vmask);
3075             }
3076         }
3077 
3078         assertReductionArraysEqualsMasked(r, ra, a, mask,
3079                 ByteMaxVectorTests::ANDReduceMasked, ByteMaxVectorTests::ANDReduceAllMasked);
3080     }
3081 
3082     static byte ORReduce(byte[] a, int idx) {
3083         byte res = 0;
3084         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3085             res |= a[i];
3086         }
3087 
3088         return res;
3089     }
3090 
3091     static byte ORReduceAll(byte[] a) {
3092         byte res = 0;
3093         for (int i = 0; i < a.length; i += SPECIES.length()) {
3094             res |= ORReduce(a, i);
3095         }
3096 
3097         return res;
3098     }
3099 
3100     @Test(dataProvider = "byteUnaryOpProvider")
3101     static void ORReduceByteMaxVectorTests(IntFunction<byte[]> fa) {
3102         byte[] a = fa.apply(SPECIES.length());
3103         byte[] r = fr.apply(SPECIES.length());
3104         byte ra = 0;
3105 
3106         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3107             for (int i = 0; i < a.length; i += SPECIES.length()) {
3108                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3109                 r[i] = av.reduceLanes(VectorOperators.OR);
3110             }
3111         }
3112 
3113         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3114             ra = 0;
3115             for (int i = 0; i < a.length; i += SPECIES.length()) {
3116                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3117                 ra |= av.reduceLanes(VectorOperators.OR);
3118             }
3119         }
3120 
3121         assertReductionArraysEquals(r, ra, a,
3122                 ByteMaxVectorTests::ORReduce, ByteMaxVectorTests::ORReduceAll);
3123     }
3124 
3125     static byte ORReduceMasked(byte[] a, int idx, boolean[] mask) {
3126         byte res = 0;
3127         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3128             if (mask[i % SPECIES.length()])
3129                 res |= a[i];
3130         }
3131 
3132         return res;
3133     }
3134 
3135     static byte ORReduceAllMasked(byte[] a, boolean[] mask) {
3136         byte res = 0;
3137         for (int i = 0; i < a.length; i += SPECIES.length()) {
3138             res |= ORReduceMasked(a, i, mask);
3139         }
3140 
3141         return res;
3142     }
3143 
3144     @Test(dataProvider = "byteUnaryOpMaskProvider")
3145     static void ORReduceByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
3146         byte[] a = fa.apply(SPECIES.length());
3147         byte[] r = fr.apply(SPECIES.length());
3148         boolean[] mask = fm.apply(SPECIES.length());
3149         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3150         byte ra = 0;
3151 
3152         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3153             for (int i = 0; i < a.length; i += SPECIES.length()) {
3154                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3155                 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
3156             }
3157         }
3158 
3159         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3160             ra = 0;
3161             for (int i = 0; i < a.length; i += SPECIES.length()) {
3162                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3163                 ra |= av.reduceLanes(VectorOperators.OR, vmask);
3164             }
3165         }
3166 
3167         assertReductionArraysEqualsMasked(r, ra, a, mask,
3168                 ByteMaxVectorTests::ORReduceMasked, ByteMaxVectorTests::ORReduceAllMasked);
3169     }
3170 
3171     static byte XORReduce(byte[] a, int idx) {
3172         byte res = 0;
3173         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3174             res ^= a[i];
3175         }
3176 
3177         return res;
3178     }
3179 
3180     static byte XORReduceAll(byte[] a) {
3181         byte res = 0;
3182         for (int i = 0; i < a.length; i += SPECIES.length()) {
3183             res ^= XORReduce(a, i);
3184         }
3185 
3186         return res;
3187     }
3188 
3189     @Test(dataProvider = "byteUnaryOpProvider")
3190     static void XORReduceByteMaxVectorTests(IntFunction<byte[]> fa) {
3191         byte[] a = fa.apply(SPECIES.length());
3192         byte[] r = fr.apply(SPECIES.length());
3193         byte ra = 0;
3194 
3195         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3196             for (int i = 0; i < a.length; i += SPECIES.length()) {
3197                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3198                 r[i] = av.reduceLanes(VectorOperators.XOR);
3199             }
3200         }
3201 
3202         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3203             ra = 0;
3204             for (int i = 0; i < a.length; i += SPECIES.length()) {
3205                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3206                 ra ^= av.reduceLanes(VectorOperators.XOR);
3207             }
3208         }
3209 
3210         assertReductionArraysEquals(r, ra, a,
3211                 ByteMaxVectorTests::XORReduce, ByteMaxVectorTests::XORReduceAll);
3212     }
3213 
3214     static byte XORReduceMasked(byte[] a, int idx, boolean[] mask) {
3215         byte res = 0;
3216         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3217             if (mask[i % SPECIES.length()])
3218                 res ^= a[i];
3219         }
3220 
3221         return res;
3222     }
3223 
3224     static byte XORReduceAllMasked(byte[] a, boolean[] mask) {
3225         byte res = 0;
3226         for (int i = 0; i < a.length; i += SPECIES.length()) {
3227             res ^= XORReduceMasked(a, i, mask);
3228         }
3229 
3230         return res;
3231     }
3232 
3233     @Test(dataProvider = "byteUnaryOpMaskProvider")
3234     static void XORReduceByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
3235         byte[] a = fa.apply(SPECIES.length());
3236         byte[] r = fr.apply(SPECIES.length());
3237         boolean[] mask = fm.apply(SPECIES.length());
3238         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3239         byte ra = 0;
3240 
3241         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3242             for (int i = 0; i < a.length; i += SPECIES.length()) {
3243                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3244                 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
3245             }
3246         }
3247 
3248         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3249             ra = 0;
3250             for (int i = 0; i < a.length; i += SPECIES.length()) {
3251                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3252                 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
3253             }
3254         }
3255 
3256         assertReductionArraysEqualsMasked(r, ra, a, mask,
3257                 ByteMaxVectorTests::XORReduceMasked, ByteMaxVectorTests::XORReduceAllMasked);
3258     }
3259 
3260     static byte ADDReduce(byte[] a, int idx) {
3261         byte res = 0;
3262         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3263             res += a[i];
3264         }
3265 
3266         return res;
3267     }
3268 
3269     static byte ADDReduceAll(byte[] a) {
3270         byte res = 0;
3271         for (int i = 0; i < a.length; i += SPECIES.length()) {
3272             res += ADDReduce(a, i);
3273         }
3274 
3275         return res;
3276     }
3277 
3278     @Test(dataProvider = "byteUnaryOpProvider")
3279     static void ADDReduceByteMaxVectorTests(IntFunction<byte[]> fa) {
3280         byte[] a = fa.apply(SPECIES.length());
3281         byte[] r = fr.apply(SPECIES.length());
3282         byte ra = 0;
3283 
3284         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3285             for (int i = 0; i < a.length; i += SPECIES.length()) {
3286                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3287                 r[i] = av.reduceLanes(VectorOperators.ADD);
3288             }
3289         }
3290 
3291         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3292             ra = 0;
3293             for (int i = 0; i < a.length; i += SPECIES.length()) {
3294                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3295                 ra += av.reduceLanes(VectorOperators.ADD);
3296             }
3297         }
3298 
3299         assertReductionArraysEquals(r, ra, a,
3300                 ByteMaxVectorTests::ADDReduce, ByteMaxVectorTests::ADDReduceAll);
3301     }
3302 
3303     static byte ADDReduceMasked(byte[] a, int idx, boolean[] mask) {
3304         byte res = 0;
3305         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3306             if (mask[i % SPECIES.length()])
3307                 res += a[i];
3308         }
3309 
3310         return res;
3311     }
3312 
3313     static byte ADDReduceAllMasked(byte[] a, boolean[] mask) {
3314         byte res = 0;
3315         for (int i = 0; i < a.length; i += SPECIES.length()) {
3316             res += ADDReduceMasked(a, i, mask);
3317         }
3318 
3319         return res;
3320     }
3321 
3322     @Test(dataProvider = "byteUnaryOpMaskProvider")
3323     static void ADDReduceByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
3324         byte[] a = fa.apply(SPECIES.length());
3325         byte[] r = fr.apply(SPECIES.length());
3326         boolean[] mask = fm.apply(SPECIES.length());
3327         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3328         byte ra = 0;
3329 
3330         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3331             for (int i = 0; i < a.length; i += SPECIES.length()) {
3332                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3333                 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
3334             }
3335         }
3336 
3337         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3338             ra = 0;
3339             for (int i = 0; i < a.length; i += SPECIES.length()) {
3340                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3341                 ra += av.reduceLanes(VectorOperators.ADD, vmask);
3342             }
3343         }
3344 
3345         assertReductionArraysEqualsMasked(r, ra, a, mask,
3346                 ByteMaxVectorTests::ADDReduceMasked, ByteMaxVectorTests::ADDReduceAllMasked);
3347     }
3348 
3349     static byte MULReduce(byte[] a, int idx) {
3350         byte res = 1;
3351         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3352             res *= a[i];
3353         }
3354 
3355         return res;
3356     }
3357 
3358     static byte MULReduceAll(byte[] a) {
3359         byte res = 1;
3360         for (int i = 0; i < a.length; i += SPECIES.length()) {
3361             res *= MULReduce(a, i);
3362         }
3363 
3364         return res;
3365     }
3366 
3367     @Test(dataProvider = "byteUnaryOpProvider")
3368     static void MULReduceByteMaxVectorTests(IntFunction<byte[]> fa) {
3369         byte[] a = fa.apply(SPECIES.length());
3370         byte[] r = fr.apply(SPECIES.length());
3371         byte ra = 1;
3372 
3373         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3374             for (int i = 0; i < a.length; i += SPECIES.length()) {
3375                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3376                 r[i] = av.reduceLanes(VectorOperators.MUL);
3377             }
3378         }
3379 
3380         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3381             ra = 1;
3382             for (int i = 0; i < a.length; i += SPECIES.length()) {
3383                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3384                 ra *= av.reduceLanes(VectorOperators.MUL);
3385             }
3386         }
3387 
3388         assertReductionArraysEquals(r, ra, a,
3389                 ByteMaxVectorTests::MULReduce, ByteMaxVectorTests::MULReduceAll);
3390     }
3391 
3392     static byte MULReduceMasked(byte[] a, int idx, boolean[] mask) {
3393         byte res = 1;
3394         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3395             if (mask[i % SPECIES.length()])
3396                 res *= a[i];
3397         }
3398 
3399         return res;
3400     }
3401 
3402     static byte MULReduceAllMasked(byte[] a, boolean[] mask) {
3403         byte res = 1;
3404         for (int i = 0; i < a.length; i += SPECIES.length()) {
3405             res *= MULReduceMasked(a, i, mask);
3406         }
3407 
3408         return res;
3409     }
3410 
3411     @Test(dataProvider = "byteUnaryOpMaskProvider")
3412     static void MULReduceByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
3413         byte[] a = fa.apply(SPECIES.length());
3414         byte[] r = fr.apply(SPECIES.length());
3415         boolean[] mask = fm.apply(SPECIES.length());
3416         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3417         byte ra = 1;
3418 
3419         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3420             for (int i = 0; i < a.length; i += SPECIES.length()) {
3421                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3422                 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
3423             }
3424         }
3425 
3426         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3427             ra = 1;
3428             for (int i = 0; i < a.length; i += SPECIES.length()) {
3429                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3430                 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
3431             }
3432         }
3433 
3434         assertReductionArraysEqualsMasked(r, ra, a, mask,
3435                 ByteMaxVectorTests::MULReduceMasked, ByteMaxVectorTests::MULReduceAllMasked);
3436     }
3437 
3438     static byte MINReduce(byte[] a, int idx) {
3439         byte res = Byte.MAX_VALUE;
3440         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3441             res = (byte) Math.min(res, a[i]);
3442         }
3443 
3444         return res;
3445     }
3446 
3447     static byte MINReduceAll(byte[] a) {
3448         byte res = Byte.MAX_VALUE;
3449         for (int i = 0; i < a.length; i += SPECIES.length()) {
3450             res = (byte) Math.min(res, MINReduce(a, i));
3451         }
3452 
3453         return res;
3454     }
3455 
3456     @Test(dataProvider = "byteUnaryOpProvider")
3457     static void MINReduceByteMaxVectorTests(IntFunction<byte[]> fa) {
3458         byte[] a = fa.apply(SPECIES.length());
3459         byte[] r = fr.apply(SPECIES.length());
3460         byte ra = Byte.MAX_VALUE;
3461 
3462         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3463             for (int i = 0; i < a.length; i += SPECIES.length()) {
3464                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3465                 r[i] = av.reduceLanes(VectorOperators.MIN);
3466             }
3467         }
3468 
3469         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3470             ra = Byte.MAX_VALUE;
3471             for (int i = 0; i < a.length; i += SPECIES.length()) {
3472                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3473                 ra = (byte) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
3474             }
3475         }
3476 
3477         assertReductionArraysEquals(r, ra, a,
3478                 ByteMaxVectorTests::MINReduce, ByteMaxVectorTests::MINReduceAll);
3479     }
3480 
3481     static byte MINReduceMasked(byte[] a, int idx, boolean[] mask) {
3482         byte res = Byte.MAX_VALUE;
3483         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3484             if (mask[i % SPECIES.length()])
3485                 res = (byte) Math.min(res, a[i]);
3486         }
3487 
3488         return res;
3489     }
3490 
3491     static byte MINReduceAllMasked(byte[] a, boolean[] mask) {
3492         byte res = Byte.MAX_VALUE;
3493         for (int i = 0; i < a.length; i += SPECIES.length()) {
3494             res = (byte) Math.min(res, MINReduceMasked(a, i, mask));
3495         }
3496 
3497         return res;
3498     }
3499 
3500     @Test(dataProvider = "byteUnaryOpMaskProvider")
3501     static void MINReduceByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
3502         byte[] a = fa.apply(SPECIES.length());
3503         byte[] r = fr.apply(SPECIES.length());
3504         boolean[] mask = fm.apply(SPECIES.length());
3505         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3506         byte ra = Byte.MAX_VALUE;
3507 
3508         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3509             for (int i = 0; i < a.length; i += SPECIES.length()) {
3510                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3511                 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
3512             }
3513         }
3514 
3515         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3516             ra = Byte.MAX_VALUE;
3517             for (int i = 0; i < a.length; i += SPECIES.length()) {
3518                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3519                 ra = (byte) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
3520             }
3521         }
3522 
3523         assertReductionArraysEqualsMasked(r, ra, a, mask,
3524                 ByteMaxVectorTests::MINReduceMasked, ByteMaxVectorTests::MINReduceAllMasked);
3525     }
3526 
3527     static byte MAXReduce(byte[] a, int idx) {
3528         byte res = Byte.MIN_VALUE;
3529         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3530             res = (byte) Math.max(res, a[i]);
3531         }
3532 
3533         return res;
3534     }
3535 
3536     static byte MAXReduceAll(byte[] a) {
3537         byte res = Byte.MIN_VALUE;
3538         for (int i = 0; i < a.length; i += SPECIES.length()) {
3539             res = (byte) Math.max(res, MAXReduce(a, i));
3540         }
3541 
3542         return res;
3543     }
3544 
3545     @Test(dataProvider = "byteUnaryOpProvider")
3546     static void MAXReduceByteMaxVectorTests(IntFunction<byte[]> fa) {
3547         byte[] a = fa.apply(SPECIES.length());
3548         byte[] r = fr.apply(SPECIES.length());
3549         byte ra = Byte.MIN_VALUE;
3550 
3551         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3552             for (int i = 0; i < a.length; i += SPECIES.length()) {
3553                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3554                 r[i] = av.reduceLanes(VectorOperators.MAX);
3555             }
3556         }
3557 
3558         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3559             ra = Byte.MIN_VALUE;
3560             for (int i = 0; i < a.length; i += SPECIES.length()) {
3561                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3562                 ra = (byte) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
3563             }
3564         }
3565 
3566         assertReductionArraysEquals(r, ra, a,
3567                 ByteMaxVectorTests::MAXReduce, ByteMaxVectorTests::MAXReduceAll);
3568     }
3569 
3570     static byte MAXReduceMasked(byte[] a, int idx, boolean[] mask) {
3571         byte res = Byte.MIN_VALUE;
3572         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3573             if (mask[i % SPECIES.length()])
3574                 res = (byte) Math.max(res, a[i]);
3575         }
3576 
3577         return res;
3578     }
3579 
3580     static byte MAXReduceAllMasked(byte[] a, boolean[] mask) {
3581         byte res = Byte.MIN_VALUE;
3582         for (int i = 0; i < a.length; i += SPECIES.length()) {
3583             res = (byte) Math.max(res, MAXReduceMasked(a, i, mask));
3584         }
3585 
3586         return res;
3587     }
3588 
3589     @Test(dataProvider = "byteUnaryOpMaskProvider")
3590     static void MAXReduceByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
3591         byte[] a = fa.apply(SPECIES.length());
3592         byte[] r = fr.apply(SPECIES.length());
3593         boolean[] mask = fm.apply(SPECIES.length());
3594         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3595         byte ra = Byte.MIN_VALUE;
3596 
3597         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3598             for (int i = 0; i < a.length; i += SPECIES.length()) {
3599                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3600                 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
3601             }
3602         }
3603 
3604         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3605             ra = Byte.MIN_VALUE;
3606             for (int i = 0; i < a.length; i += SPECIES.length()) {
3607                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3608                 ra = (byte) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
3609             }
3610         }
3611 
3612         assertReductionArraysEqualsMasked(r, ra, a, mask,
3613                 ByteMaxVectorTests::MAXReduceMasked, ByteMaxVectorTests::MAXReduceAllMasked);
3614     }
3615 
3616     static byte FIRST_NONZEROReduce(byte[] a, int idx) {
3617         byte res = (byte) 0;
3618         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3619             res = firstNonZero(res, a[i]);
3620         }
3621 
3622         return res;
3623     }
3624 
3625     static byte FIRST_NONZEROReduceAll(byte[] a) {
3626         byte res = (byte) 0;
3627         for (int i = 0; i < a.length; i += SPECIES.length()) {
3628             res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
3629         }
3630 
3631         return res;
3632     }
3633 
3634     @Test(dataProvider = "byteUnaryOpProvider")
3635     static void FIRST_NONZEROReduceByteMaxVectorTests(IntFunction<byte[]> fa) {
3636         byte[] a = fa.apply(SPECIES.length());
3637         byte[] r = fr.apply(SPECIES.length());
3638         byte ra = (byte) 0;
3639 
3640         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3641             for (int i = 0; i < a.length; i += SPECIES.length()) {
3642                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3643                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
3644             }
3645         }
3646 
3647         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3648             ra = (byte) 0;
3649             for (int i = 0; i < a.length; i += SPECIES.length()) {
3650                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3651                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
3652             }
3653         }
3654 
3655         assertReductionArraysEquals(r, ra, a,
3656                 ByteMaxVectorTests::FIRST_NONZEROReduce, ByteMaxVectorTests::FIRST_NONZEROReduceAll);
3657     }
3658 
3659     static byte FIRST_NONZEROReduceMasked(byte[] a, int idx, boolean[] mask) {
3660         byte res = (byte) 0;
3661         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3662             if (mask[i % SPECIES.length()])
3663                 res = firstNonZero(res, a[i]);
3664         }
3665 
3666         return res;
3667     }
3668 
3669     static byte FIRST_NONZEROReduceAllMasked(byte[] a, boolean[] mask) {
3670         byte res = (byte) 0;
3671         for (int i = 0; i < a.length; i += SPECIES.length()) {
3672             res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
3673         }
3674 
3675         return res;
3676     }
3677 
3678     @Test(dataProvider = "byteUnaryOpMaskProvider")
3679     static void FIRST_NONZEROReduceByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
3680         byte[] a = fa.apply(SPECIES.length());
3681         byte[] r = fr.apply(SPECIES.length());
3682         boolean[] mask = fm.apply(SPECIES.length());
3683         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3684         byte ra = (byte) 0;
3685 
3686         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3687             for (int i = 0; i < a.length; i += SPECIES.length()) {
3688                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3689                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
3690             }
3691         }
3692 
3693         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3694             ra = (byte) 0;
3695             for (int i = 0; i < a.length; i += SPECIES.length()) {
3696                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3697                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
3698             }
3699         }
3700 
3701         assertReductionArraysEqualsMasked(r, ra, a, mask,
3702                 ByteMaxVectorTests::FIRST_NONZEROReduceMasked, ByteMaxVectorTests::FIRST_NONZEROReduceAllMasked);
3703     }
3704 
3705     static boolean anyTrue(boolean[] a, int idx) {
3706         boolean res = false;
3707         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3708             res |= a[i];
3709         }
3710 
3711         return res;
3712     }
3713 
3714     @Test(dataProvider = "boolUnaryOpProvider")
3715     static void anyTrueByteMaxVectorTests(IntFunction<boolean[]> fm) {
3716         boolean[] mask = fm.apply(SPECIES.length());
3717         boolean[] r = fmr.apply(SPECIES.length());
3718 
3719         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3720             for (int i = 0; i < mask.length; i += SPECIES.length()) {
3721                 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, i);
3722                 r[i] = vmask.anyTrue();
3723             }
3724         }
3725 
3726         assertReductionBoolArraysEquals(r, mask, ByteMaxVectorTests::anyTrue);
3727     }
3728 
3729     static boolean allTrue(boolean[] a, int idx) {
3730         boolean res = true;
3731         for (int i = idx; i < (idx + SPECIES.length()); i++) {
3732             res &= a[i];
3733         }
3734 
3735         return res;
3736     }
3737 
3738     @Test(dataProvider = "boolUnaryOpProvider")
3739     static void allTrueByteMaxVectorTests(IntFunction<boolean[]> fm) {
3740         boolean[] mask = fm.apply(SPECIES.length());
3741         boolean[] r = fmr.apply(SPECIES.length());
3742 
3743         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3744             for (int i = 0; i < mask.length; i += SPECIES.length()) {
3745                 VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, i);
3746                 r[i] = vmask.allTrue();
3747             }
3748         }
3749 
3750         assertReductionBoolArraysEquals(r, mask, ByteMaxVectorTests::allTrue);
3751     }
3752 
3753     @Test(dataProvider = "byteUnaryOpProvider")
3754     static void withByteMaxVectorTests(IntFunction<byte []> fa) {
3755         byte[] a = fa.apply(SPECIES.length());
3756         byte[] r = fr.apply(SPECIES.length());
3757 
3758         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3759             for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
3760                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3761                 av.withLane((j++ & (SPECIES.length()-1)), (byte)(65535+i)).intoArray(r, i);
3762             }
3763         }
3764 
3765 
3766         for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
3767             assertInsertArraysEquals(r, a, (byte)(65535+i), (j++ & (SPECIES.length()-1)), i , i + SPECIES.length());
3768         }
3769     }
3770 
3771     static boolean testIS_DEFAULT(byte a) {
3772         return bits(a)==0;
3773     }
3774 
3775     @Test(dataProvider = "byteTestOpProvider")
3776     static void IS_DEFAULTByteMaxVectorTests(IntFunction<byte[]> fa) {
3777         byte[] a = fa.apply(SPECIES.length());
3778 
3779         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3780             for (int i = 0; i < a.length; i += SPECIES.length()) {
3781                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3782                 VectorMask<Byte> mv = av.test(VectorOperators.IS_DEFAULT);
3783 
3784                 // Check results as part of computation.
3785                 for (int j = 0; j < SPECIES.length(); j++) {
3786                     Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
3787                 }
3788             }
3789         }
3790     }
3791 
3792     @Test(dataProvider = "byteTestOpMaskProvider")
3793     static void IS_DEFAULTMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
3794                                           IntFunction<boolean[]> fm) {
3795         byte[] a = fa.apply(SPECIES.length());
3796         boolean[] mask = fm.apply(SPECIES.length());
3797         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3798 
3799         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3800             for (int i = 0; i < a.length; i += SPECIES.length()) {
3801                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3802                 VectorMask<Byte> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
3803 
3804                 // Check results as part of computation.
3805                 for (int j = 0; j < SPECIES.length(); j++) {
3806                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
3807                 }
3808             }
3809         }
3810     }
3811 
3812     static boolean testIS_NEGATIVE(byte a) {
3813         return bits(a)<0;
3814     }
3815 
3816     @Test(dataProvider = "byteTestOpProvider")
3817     static void IS_NEGATIVEByteMaxVectorTests(IntFunction<byte[]> fa) {
3818         byte[] a = fa.apply(SPECIES.length());
3819 
3820         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3821             for (int i = 0; i < a.length; i += SPECIES.length()) {
3822                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3823                 VectorMask<Byte> mv = av.test(VectorOperators.IS_NEGATIVE);
3824 
3825                 // Check results as part of computation.
3826                 for (int j = 0; j < SPECIES.length(); j++) {
3827                     Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
3828                 }
3829             }
3830         }
3831     }
3832 
3833     @Test(dataProvider = "byteTestOpMaskProvider")
3834     static void IS_NEGATIVEMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
3835                                           IntFunction<boolean[]> fm) {
3836         byte[] a = fa.apply(SPECIES.length());
3837         boolean[] mask = fm.apply(SPECIES.length());
3838         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3839 
3840         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3841             for (int i = 0; i < a.length; i += SPECIES.length()) {
3842                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3843                 VectorMask<Byte> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
3844 
3845                 // Check results as part of computation.
3846                 for (int j = 0; j < SPECIES.length(); j++) {
3847                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
3848                 }
3849             }
3850         }
3851     }
3852 
3853     @Test(dataProvider = "byteCompareOpProvider")
3854     static void LTByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
3855         byte[] a = fa.apply(SPECIES.length());
3856         byte[] b = fb.apply(SPECIES.length());
3857 
3858         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3859             for (int i = 0; i < a.length; i += SPECIES.length()) {
3860                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3861                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
3862                 VectorMask<Byte> mv = av.compare(VectorOperators.LT, bv);
3863 
3864                 // Check results as part of computation.
3865                 for (int j = 0; j < SPECIES.length(); j++) {
3866                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3867                 }
3868             }
3869         }
3870     }
3871 
3872     @Test(dataProvider = "byteCompareOpProvider")
3873     static void ltByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
3874         byte[] a = fa.apply(SPECIES.length());
3875         byte[] b = fb.apply(SPECIES.length());
3876 
3877         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3878             for (int i = 0; i < a.length; i += SPECIES.length()) {
3879                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3880                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
3881                 VectorMask<Byte> mv = av.lt(bv);
3882 
3883                 // Check results as part of computation.
3884                 for (int j = 0; j < SPECIES.length(); j++) {
3885                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3886                 }
3887             }
3888         }
3889     }
3890 
3891     @Test(dataProvider = "byteCompareOpMaskProvider")
3892     static void LTByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
3893                                                 IntFunction<boolean[]> fm) {
3894         byte[] a = fa.apply(SPECIES.length());
3895         byte[] b = fb.apply(SPECIES.length());
3896         boolean[] mask = fm.apply(SPECIES.length());
3897 
3898         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3899 
3900         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3901             for (int i = 0; i < a.length; i += SPECIES.length()) {
3902                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3903                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
3904                 VectorMask<Byte> mv = av.compare(VectorOperators.LT, bv, vmask);
3905 
3906                 // Check results as part of computation.
3907                 for (int j = 0; j < SPECIES.length(); j++) {
3908                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
3909                 }
3910             }
3911         }
3912     }
3913 
3914     @Test(dataProvider = "byteCompareOpProvider")
3915     static void GTByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
3916         byte[] a = fa.apply(SPECIES.length());
3917         byte[] b = fb.apply(SPECIES.length());
3918 
3919         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3920             for (int i = 0; i < a.length; i += SPECIES.length()) {
3921                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3922                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
3923                 VectorMask<Byte> mv = av.compare(VectorOperators.GT, bv);
3924 
3925                 // Check results as part of computation.
3926                 for (int j = 0; j < SPECIES.length(); j++) {
3927                     Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
3928                 }
3929             }
3930         }
3931     }
3932 
3933     @Test(dataProvider = "byteCompareOpMaskProvider")
3934     static void GTByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
3935                                                 IntFunction<boolean[]> fm) {
3936         byte[] a = fa.apply(SPECIES.length());
3937         byte[] b = fb.apply(SPECIES.length());
3938         boolean[] mask = fm.apply(SPECIES.length());
3939 
3940         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3941 
3942         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3943             for (int i = 0; i < a.length; i += SPECIES.length()) {
3944                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3945                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
3946                 VectorMask<Byte> mv = av.compare(VectorOperators.GT, bv, vmask);
3947 
3948                 // Check results as part of computation.
3949                 for (int j = 0; j < SPECIES.length(); j++) {
3950                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
3951                 }
3952             }
3953         }
3954     }
3955 
3956     @Test(dataProvider = "byteCompareOpProvider")
3957     static void EQByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
3958         byte[] a = fa.apply(SPECIES.length());
3959         byte[] b = fb.apply(SPECIES.length());
3960 
3961         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3962             for (int i = 0; i < a.length; i += SPECIES.length()) {
3963                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3964                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
3965                 VectorMask<Byte> mv = av.compare(VectorOperators.EQ, bv);
3966 
3967                 // Check results as part of computation.
3968                 for (int j = 0; j < SPECIES.length(); j++) {
3969                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3970                 }
3971             }
3972         }
3973     }
3974 
3975     @Test(dataProvider = "byteCompareOpProvider")
3976     static void eqByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
3977         byte[] a = fa.apply(SPECIES.length());
3978         byte[] b = fb.apply(SPECIES.length());
3979 
3980         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3981             for (int i = 0; i < a.length; i += SPECIES.length()) {
3982                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
3983                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
3984                 VectorMask<Byte> mv = av.eq(bv);
3985 
3986                 // Check results as part of computation.
3987                 for (int j = 0; j < SPECIES.length(); j++) {
3988                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3989                 }
3990             }
3991         }
3992     }
3993 
3994     @Test(dataProvider = "byteCompareOpMaskProvider")
3995     static void EQByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
3996                                                 IntFunction<boolean[]> fm) {
3997         byte[] a = fa.apply(SPECIES.length());
3998         byte[] b = fb.apply(SPECIES.length());
3999         boolean[] mask = fm.apply(SPECIES.length());
4000 
4001         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4002 
4003         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4004             for (int i = 0; i < a.length; i += SPECIES.length()) {
4005                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4006                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4007                 VectorMask<Byte> mv = av.compare(VectorOperators.EQ, bv, vmask);
4008 
4009                 // Check results as part of computation.
4010                 for (int j = 0; j < SPECIES.length(); j++) {
4011                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
4012                 }
4013             }
4014         }
4015     }
4016 
4017     @Test(dataProvider = "byteCompareOpProvider")
4018     static void NEByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4019         byte[] a = fa.apply(SPECIES.length());
4020         byte[] b = fb.apply(SPECIES.length());
4021 
4022         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4023             for (int i = 0; i < a.length; i += SPECIES.length()) {
4024                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4025                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4026                 VectorMask<Byte> mv = av.compare(VectorOperators.NE, bv);
4027 
4028                 // Check results as part of computation.
4029                 for (int j = 0; j < SPECIES.length(); j++) {
4030                     Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
4031                 }
4032             }
4033         }
4034     }
4035 
4036     @Test(dataProvider = "byteCompareOpMaskProvider")
4037     static void NEByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4038                                                 IntFunction<boolean[]> fm) {
4039         byte[] a = fa.apply(SPECIES.length());
4040         byte[] b = fb.apply(SPECIES.length());
4041         boolean[] mask = fm.apply(SPECIES.length());
4042 
4043         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4044 
4045         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4046             for (int i = 0; i < a.length; i += SPECIES.length()) {
4047                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4048                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4049                 VectorMask<Byte> mv = av.compare(VectorOperators.NE, bv, vmask);
4050 
4051                 // Check results as part of computation.
4052                 for (int j = 0; j < SPECIES.length(); j++) {
4053                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
4054                 }
4055             }
4056         }
4057     }
4058 
4059     @Test(dataProvider = "byteCompareOpProvider")
4060     static void LEByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4061         byte[] a = fa.apply(SPECIES.length());
4062         byte[] b = fb.apply(SPECIES.length());
4063 
4064         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4065             for (int i = 0; i < a.length; i += SPECIES.length()) {
4066                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4067                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4068                 VectorMask<Byte> mv = av.compare(VectorOperators.LE, bv);
4069 
4070                 // Check results as part of computation.
4071                 for (int j = 0; j < SPECIES.length(); j++) {
4072                     Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
4073                 }
4074             }
4075         }
4076     }
4077 
4078     @Test(dataProvider = "byteCompareOpMaskProvider")
4079     static void LEByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4080                                                 IntFunction<boolean[]> fm) {
4081         byte[] a = fa.apply(SPECIES.length());
4082         byte[] b = fb.apply(SPECIES.length());
4083         boolean[] mask = fm.apply(SPECIES.length());
4084 
4085         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4086 
4087         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4088             for (int i = 0; i < a.length; i += SPECIES.length()) {
4089                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4090                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4091                 VectorMask<Byte> mv = av.compare(VectorOperators.LE, bv, vmask);
4092 
4093                 // Check results as part of computation.
4094                 for (int j = 0; j < SPECIES.length(); j++) {
4095                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
4096                 }
4097             }
4098         }
4099     }
4100 
4101     @Test(dataProvider = "byteCompareOpProvider")
4102     static void GEByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4103         byte[] a = fa.apply(SPECIES.length());
4104         byte[] b = fb.apply(SPECIES.length());
4105 
4106         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4107             for (int i = 0; i < a.length; i += SPECIES.length()) {
4108                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4109                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4110                 VectorMask<Byte> mv = av.compare(VectorOperators.GE, bv);
4111 
4112                 // Check results as part of computation.
4113                 for (int j = 0; j < SPECIES.length(); j++) {
4114                     Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
4115                 }
4116             }
4117         }
4118     }
4119 
4120     @Test(dataProvider = "byteCompareOpMaskProvider")
4121     static void GEByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4122                                                 IntFunction<boolean[]> fm) {
4123         byte[] a = fa.apply(SPECIES.length());
4124         byte[] b = fb.apply(SPECIES.length());
4125         boolean[] mask = fm.apply(SPECIES.length());
4126 
4127         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4128 
4129         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4130             for (int i = 0; i < a.length; i += SPECIES.length()) {
4131                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4132                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4133                 VectorMask<Byte> mv = av.compare(VectorOperators.GE, bv, vmask);
4134 
4135                 // Check results as part of computation.
4136                 for (int j = 0; j < SPECIES.length(); j++) {
4137                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
4138                 }
4139             }
4140         }
4141     }
4142 
4143     @Test(dataProvider = "byteCompareOpProvider")
4144     static void UNSIGNED_LTByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4145         byte[] a = fa.apply(SPECIES.length());
4146         byte[] b = fb.apply(SPECIES.length());
4147 
4148         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4149             for (int i = 0; i < a.length; i += SPECIES.length()) {
4150                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4151                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4152                 VectorMask<Byte> mv = av.compare(VectorOperators.UNSIGNED_LT, bv);
4153 
4154                 // Check results as part of computation.
4155                 for (int j = 0; j < SPECIES.length(); j++) {
4156                     Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
4157                 }
4158             }
4159         }
4160     }
4161 
4162     @Test(dataProvider = "byteCompareOpMaskProvider")
4163     static void UNSIGNED_LTByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4164                                                 IntFunction<boolean[]> fm) {
4165         byte[] a = fa.apply(SPECIES.length());
4166         byte[] b = fb.apply(SPECIES.length());
4167         boolean[] mask = fm.apply(SPECIES.length());
4168 
4169         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4170 
4171         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4172             for (int i = 0; i < a.length; i += SPECIES.length()) {
4173                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4174                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4175                 VectorMask<Byte> mv = av.compare(VectorOperators.UNSIGNED_LT, bv, vmask);
4176 
4177                 // Check results as part of computation.
4178                 for (int j = 0; j < SPECIES.length(); j++) {
4179                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
4180                 }
4181             }
4182         }
4183     }
4184 
4185     @Test(dataProvider = "byteCompareOpProvider")
4186     static void UNSIGNED_GTByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4187         byte[] a = fa.apply(SPECIES.length());
4188         byte[] b = fb.apply(SPECIES.length());
4189 
4190         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4191             for (int i = 0; i < a.length; i += SPECIES.length()) {
4192                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4193                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4194                 VectorMask<Byte> mv = av.compare(VectorOperators.UNSIGNED_GT, bv);
4195 
4196                 // Check results as part of computation.
4197                 for (int j = 0; j < SPECIES.length(); j++) {
4198                     Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
4199                 }
4200             }
4201         }
4202     }
4203 
4204     @Test(dataProvider = "byteCompareOpMaskProvider")
4205     static void UNSIGNED_GTByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4206                                                 IntFunction<boolean[]> fm) {
4207         byte[] a = fa.apply(SPECIES.length());
4208         byte[] b = fb.apply(SPECIES.length());
4209         boolean[] mask = fm.apply(SPECIES.length());
4210 
4211         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4212 
4213         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4214             for (int i = 0; i < a.length; i += SPECIES.length()) {
4215                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4216                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4217                 VectorMask<Byte> mv = av.compare(VectorOperators.UNSIGNED_GT, bv, vmask);
4218 
4219                 // Check results as part of computation.
4220                 for (int j = 0; j < SPECIES.length(); j++) {
4221                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
4222                 }
4223             }
4224         }
4225     }
4226 
4227     @Test(dataProvider = "byteCompareOpProvider")
4228     static void UNSIGNED_LEByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4229         byte[] a = fa.apply(SPECIES.length());
4230         byte[] b = fb.apply(SPECIES.length());
4231 
4232         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4233             for (int i = 0; i < a.length; i += SPECIES.length()) {
4234                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4235                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4236                 VectorMask<Byte> mv = av.compare(VectorOperators.UNSIGNED_LE, bv);
4237 
4238                 // Check results as part of computation.
4239                 for (int j = 0; j < SPECIES.length(); j++) {
4240                     Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
4241                 }
4242             }
4243         }
4244     }
4245 
4246     @Test(dataProvider = "byteCompareOpMaskProvider")
4247     static void UNSIGNED_LEByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4248                                                 IntFunction<boolean[]> fm) {
4249         byte[] a = fa.apply(SPECIES.length());
4250         byte[] b = fb.apply(SPECIES.length());
4251         boolean[] mask = fm.apply(SPECIES.length());
4252 
4253         VectorMask<Byte> 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                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4258                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4259                 VectorMask<Byte> mv = av.compare(VectorOperators.UNSIGNED_LE, 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] && ule(a[i + j], b[i + j]));
4264                 }
4265             }
4266         }
4267     }
4268 
4269     @Test(dataProvider = "byteCompareOpProvider")
4270     static void UNSIGNED_GEByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4271         byte[] a = fa.apply(SPECIES.length());
4272         byte[] b = fb.apply(SPECIES.length());
4273 
4274         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4275             for (int i = 0; i < a.length; i += SPECIES.length()) {
4276                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4277                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4278                 VectorMask<Byte> mv = av.compare(VectorOperators.UNSIGNED_GE, bv);
4279 
4280                 // Check results as part of computation.
4281                 for (int j = 0; j < SPECIES.length(); j++) {
4282                     Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
4283                 }
4284             }
4285         }
4286     }
4287 
4288     @Test(dataProvider = "byteCompareOpMaskProvider")
4289     static void UNSIGNED_GEByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4290                                                 IntFunction<boolean[]> fm) {
4291         byte[] a = fa.apply(SPECIES.length());
4292         byte[] b = fb.apply(SPECIES.length());
4293         boolean[] mask = fm.apply(SPECIES.length());
4294 
4295         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4296 
4297         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4298             for (int i = 0; i < a.length; i += SPECIES.length()) {
4299                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4300                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4301                 VectorMask<Byte> mv = av.compare(VectorOperators.UNSIGNED_GE, bv, vmask);
4302 
4303                 // Check results as part of computation.
4304                 for (int j = 0; j < SPECIES.length(); j++) {
4305                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
4306                 }
4307             }
4308         }
4309     }
4310 
4311     @Test(dataProvider = "byteCompareOpProvider")
4312     static void LTByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4313         byte[] a = fa.apply(SPECIES.length());
4314         byte[] b = fb.apply(SPECIES.length());
4315 
4316         for (int i = 0; i < a.length; i += SPECIES.length()) {
4317             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4318             VectorMask<Byte> mv = av.compare(VectorOperators.LT, b[i]);
4319 
4320             // Check results as part of computation.
4321             for (int j = 0; j < SPECIES.length(); j++) {
4322                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
4323             }
4324         }
4325     }
4326 
4327     @Test(dataProvider = "byteCompareOpMaskProvider")
4328     static void LTByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa,
4329                                 IntFunction<byte[]> fb, IntFunction<boolean[]> fm) {
4330         byte[] a = fa.apply(SPECIES.length());
4331         byte[] b = fb.apply(SPECIES.length());
4332         boolean[] mask = fm.apply(SPECIES.length());
4333 
4334         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4335 
4336         for (int i = 0; i < a.length; i += SPECIES.length()) {
4337             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4338             VectorMask<Byte> mv = av.compare(VectorOperators.LT, b[i], vmask);
4339 
4340             // Check results as part of computation.
4341             for (int j = 0; j < SPECIES.length(); j++) {
4342                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
4343             }
4344         }
4345     }
4346 
4347     @Test(dataProvider = "byteCompareOpProvider")
4348     static void LTByteMaxVectorTestsBroadcastLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4349         byte[] a = fa.apply(SPECIES.length());
4350         byte[] b = fb.apply(SPECIES.length());
4351 
4352         for (int i = 0; i < a.length; i += SPECIES.length()) {
4353             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4354             VectorMask<Byte> mv = av.compare(VectorOperators.LT, (long)b[i]);
4355 
4356             // Check results as part of computation.
4357             for (int j = 0; j < SPECIES.length(); j++) {
4358                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (byte)((long)b[i]));
4359             }
4360         }
4361     }
4362 
4363     @Test(dataProvider = "byteCompareOpMaskProvider")
4364     static void LTByteMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<byte[]> fa,
4365                                 IntFunction<byte[]> fb, IntFunction<boolean[]> fm) {
4366         byte[] a = fa.apply(SPECIES.length());
4367         byte[] b = fb.apply(SPECIES.length());
4368         boolean[] mask = fm.apply(SPECIES.length());
4369 
4370         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4371 
4372         for (int i = 0; i < a.length; i += SPECIES.length()) {
4373             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4374             VectorMask<Byte> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
4375 
4376             // Check results as part of computation.
4377             for (int j = 0; j < SPECIES.length(); j++) {
4378                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (byte)((long)b[i])));
4379             }
4380         }
4381     }
4382 
4383     @Test(dataProvider = "byteCompareOpProvider")
4384     static void EQByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4385         byte[] a = fa.apply(SPECIES.length());
4386         byte[] b = fb.apply(SPECIES.length());
4387 
4388         for (int i = 0; i < a.length; i += SPECIES.length()) {
4389             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4390             VectorMask<Byte> mv = av.compare(VectorOperators.EQ, b[i]);
4391 
4392             // Check results as part of computation.
4393             for (int j = 0; j < SPECIES.length(); j++) {
4394                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
4395             }
4396         }
4397     }
4398 
4399     @Test(dataProvider = "byteCompareOpMaskProvider")
4400     static void EQByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa,
4401                                 IntFunction<byte[]> fb, IntFunction<boolean[]> fm) {
4402         byte[] a = fa.apply(SPECIES.length());
4403         byte[] b = fb.apply(SPECIES.length());
4404         boolean[] mask = fm.apply(SPECIES.length());
4405 
4406         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4407 
4408         for (int i = 0; i < a.length; i += SPECIES.length()) {
4409             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4410             VectorMask<Byte> mv = av.compare(VectorOperators.EQ, b[i], vmask);
4411 
4412             // Check results as part of computation.
4413             for (int j = 0; j < SPECIES.length(); j++) {
4414                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
4415             }
4416         }
4417     }
4418 
4419     @Test(dataProvider = "byteCompareOpProvider")
4420     static void EQByteMaxVectorTestsBroadcastLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4421         byte[] a = fa.apply(SPECIES.length());
4422         byte[] b = fb.apply(SPECIES.length());
4423 
4424         for (int i = 0; i < a.length; i += SPECIES.length()) {
4425             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4426             VectorMask<Byte> mv = av.compare(VectorOperators.EQ, (long)b[i]);
4427 
4428             // Check results as part of computation.
4429             for (int j = 0; j < SPECIES.length(); j++) {
4430                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (byte)((long)b[i]));
4431             }
4432         }
4433     }
4434 
4435     @Test(dataProvider = "byteCompareOpMaskProvider")
4436     static void EQByteMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<byte[]> fa,
4437                                 IntFunction<byte[]> fb, IntFunction<boolean[]> fm) {
4438         byte[] a = fa.apply(SPECIES.length());
4439         byte[] b = fb.apply(SPECIES.length());
4440         boolean[] mask = fm.apply(SPECIES.length());
4441 
4442         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4443 
4444         for (int i = 0; i < a.length; i += SPECIES.length()) {
4445             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4446             VectorMask<Byte> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
4447 
4448             // Check results as part of computation.
4449             for (int j = 0; j < SPECIES.length(); j++) {
4450                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (byte)((long)b[i])));
4451             }
4452         }
4453     }
4454 
4455     static byte blend(byte a, byte b, boolean mask) {
4456         return mask ? b : a;
4457     }
4458 
4459     @Test(dataProvider = "byteBinaryOpMaskProvider")
4460     static void blendByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4461                                           IntFunction<boolean[]> fm) {
4462         byte[] a = fa.apply(SPECIES.length());
4463         byte[] b = fb.apply(SPECIES.length());
4464         byte[] r = fr.apply(SPECIES.length());
4465         boolean[] mask = fm.apply(SPECIES.length());
4466         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4467 
4468         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4469             for (int i = 0; i < a.length; i += SPECIES.length()) {
4470                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4471                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4472                 av.blend(bv, vmask).intoArray(r, i);
4473             }
4474         }
4475 
4476         assertArraysEquals(r, a, b, mask, ByteMaxVectorTests::blend);
4477     }
4478 
4479     @Test(dataProvider = "byteUnaryOpShuffleProvider")
4480     static void RearrangeByteMaxVectorTests(IntFunction<byte[]> fa,
4481                                            BiFunction<Integer,Integer,int[]> fs) {
4482         byte[] a = fa.apply(SPECIES.length());
4483         int[] order = fs.apply(a.length, SPECIES.length());
4484         byte[] r = fr.apply(SPECIES.length());
4485 
4486         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4487             for (int i = 0; i < a.length; i += SPECIES.length()) {
4488                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4489                 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
4490             }
4491         }
4492 
4493         assertRearrangeArraysEquals(r, a, order, SPECIES.length());
4494     }
4495 
4496     @Test(dataProvider = "byteUnaryOpShuffleMaskProvider")
4497     static void RearrangeByteMaxVectorTestsMaskedSmokeTest(IntFunction<byte[]> fa,
4498                                                           BiFunction<Integer,Integer,int[]> fs,
4499                                                           IntFunction<boolean[]> fm) {
4500         byte[] a = fa.apply(SPECIES.length());
4501         int[] order = fs.apply(a.length, SPECIES.length());
4502         byte[] r = fr.apply(SPECIES.length());
4503         boolean[] mask = fm.apply(SPECIES.length());
4504         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4505 
4506         for (int i = 0; i < a.length; i += SPECIES.length()) {
4507             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4508             av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
4509         }
4510 
4511         assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
4512     }
4513 
4514     @Test(dataProvider = "byteUnaryOpMaskProvider")
4515     static void compressByteMaxVectorTests(IntFunction<byte[]> fa,
4516                                                 IntFunction<boolean[]> fm) {
4517         byte[] a = fa.apply(SPECIES.length());
4518         byte[] r = fr.apply(SPECIES.length());
4519         boolean[] mask = fm.apply(SPECIES.length());
4520         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4521 
4522         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4523             for (int i = 0; i < a.length; i += SPECIES.length()) {
4524                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4525                 av.compress(vmask).intoArray(r, i);
4526             }
4527         }
4528 
4529         assertcompressArraysEquals(r, a, mask, SPECIES.length());
4530     }
4531 
4532     @Test(dataProvider = "byteUnaryOpMaskProvider")
4533     static void expandByteMaxVectorTests(IntFunction<byte[]> fa,
4534                                                 IntFunction<boolean[]> fm) {
4535         byte[] a = fa.apply(SPECIES.length());
4536         byte[] r = fr.apply(SPECIES.length());
4537         boolean[] mask = fm.apply(SPECIES.length());
4538         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4539 
4540         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4541             for (int i = 0; i < a.length; i += SPECIES.length()) {
4542                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4543                 av.expand(vmask).intoArray(r, i);
4544             }
4545         }
4546 
4547         assertexpandArraysEquals(r, a, mask, SPECIES.length());
4548     }
4549 
4550     @Test(dataProvider = "byteUnaryOpProvider")
4551     static void getByteMaxVectorTests(IntFunction<byte[]> fa) {
4552         byte[] a = fa.apply(SPECIES.length());
4553         byte[] r = fr.apply(SPECIES.length());
4554 
4555         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4556             for (int i = 0; i < a.length; i += SPECIES.length()) {
4557                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4558                 int num_lanes = SPECIES.length();
4559                 // Manually unroll because full unroll happens after intrinsification.
4560                 // Unroll is needed because get intrinsic requires for index to be a known constant.
4561                 if (num_lanes == 1) {
4562                     r[i]=av.lane(0);
4563                 } else if (num_lanes == 2) {
4564                     r[i]=av.lane(0);
4565                     r[i+1]=av.lane(1);
4566                 } else if (num_lanes == 4) {
4567                     r[i]=av.lane(0);
4568                     r[i+1]=av.lane(1);
4569                     r[i+2]=av.lane(2);
4570                     r[i+3]=av.lane(3);
4571                 } else if (num_lanes == 8) {
4572                     r[i]=av.lane(0);
4573                     r[i+1]=av.lane(1);
4574                     r[i+2]=av.lane(2);
4575                     r[i+3]=av.lane(3);
4576                     r[i+4]=av.lane(4);
4577                     r[i+5]=av.lane(5);
4578                     r[i+6]=av.lane(6);
4579                     r[i+7]=av.lane(7);
4580                 } else if (num_lanes == 16) {
4581                     r[i]=av.lane(0);
4582                     r[i+1]=av.lane(1);
4583                     r[i+2]=av.lane(2);
4584                     r[i+3]=av.lane(3);
4585                     r[i+4]=av.lane(4);
4586                     r[i+5]=av.lane(5);
4587                     r[i+6]=av.lane(6);
4588                     r[i+7]=av.lane(7);
4589                     r[i+8]=av.lane(8);
4590                     r[i+9]=av.lane(9);
4591                     r[i+10]=av.lane(10);
4592                     r[i+11]=av.lane(11);
4593                     r[i+12]=av.lane(12);
4594                     r[i+13]=av.lane(13);
4595                     r[i+14]=av.lane(14);
4596                     r[i+15]=av.lane(15);
4597                 } else if (num_lanes == 32) {
4598                     r[i]=av.lane(0);
4599                     r[i+1]=av.lane(1);
4600                     r[i+2]=av.lane(2);
4601                     r[i+3]=av.lane(3);
4602                     r[i+4]=av.lane(4);
4603                     r[i+5]=av.lane(5);
4604                     r[i+6]=av.lane(6);
4605                     r[i+7]=av.lane(7);
4606                     r[i+8]=av.lane(8);
4607                     r[i+9]=av.lane(9);
4608                     r[i+10]=av.lane(10);
4609                     r[i+11]=av.lane(11);
4610                     r[i+12]=av.lane(12);
4611                     r[i+13]=av.lane(13);
4612                     r[i+14]=av.lane(14);
4613                     r[i+15]=av.lane(15);
4614                     r[i+16]=av.lane(16);
4615                     r[i+17]=av.lane(17);
4616                     r[i+18]=av.lane(18);
4617                     r[i+19]=av.lane(19);
4618                     r[i+20]=av.lane(20);
4619                     r[i+21]=av.lane(21);
4620                     r[i+22]=av.lane(22);
4621                     r[i+23]=av.lane(23);
4622                     r[i+24]=av.lane(24);
4623                     r[i+25]=av.lane(25);
4624                     r[i+26]=av.lane(26);
4625                     r[i+27]=av.lane(27);
4626                     r[i+28]=av.lane(28);
4627                     r[i+29]=av.lane(29);
4628                     r[i+30]=av.lane(30);
4629                     r[i+31]=av.lane(31);
4630                 } else if (num_lanes == 64) {
4631                     r[i]=av.lane(0);
4632                     r[i+1]=av.lane(1);
4633                     r[i+2]=av.lane(2);
4634                     r[i+3]=av.lane(3);
4635                     r[i+4]=av.lane(4);
4636                     r[i+5]=av.lane(5);
4637                     r[i+6]=av.lane(6);
4638                     r[i+7]=av.lane(7);
4639                     r[i+8]=av.lane(8);
4640                     r[i+9]=av.lane(9);
4641                     r[i+10]=av.lane(10);
4642                     r[i+11]=av.lane(11);
4643                     r[i+12]=av.lane(12);
4644                     r[i+13]=av.lane(13);
4645                     r[i+14]=av.lane(14);
4646                     r[i+15]=av.lane(15);
4647                     r[i+16]=av.lane(16);
4648                     r[i+17]=av.lane(17);
4649                     r[i+18]=av.lane(18);
4650                     r[i+19]=av.lane(19);
4651                     r[i+20]=av.lane(20);
4652                     r[i+21]=av.lane(21);
4653                     r[i+22]=av.lane(22);
4654                     r[i+23]=av.lane(23);
4655                     r[i+24]=av.lane(24);
4656                     r[i+25]=av.lane(25);
4657                     r[i+26]=av.lane(26);
4658                     r[i+27]=av.lane(27);
4659                     r[i+28]=av.lane(28);
4660                     r[i+29]=av.lane(29);
4661                     r[i+30]=av.lane(30);
4662                     r[i+31]=av.lane(31);
4663                     r[i+32]=av.lane(32);
4664                     r[i+33]=av.lane(33);
4665                     r[i+34]=av.lane(34);
4666                     r[i+35]=av.lane(35);
4667                     r[i+36]=av.lane(36);
4668                     r[i+37]=av.lane(37);
4669                     r[i+38]=av.lane(38);
4670                     r[i+39]=av.lane(39);
4671                     r[i+40]=av.lane(40);
4672                     r[i+41]=av.lane(41);
4673                     r[i+42]=av.lane(42);
4674                     r[i+43]=av.lane(43);
4675                     r[i+44]=av.lane(44);
4676                     r[i+45]=av.lane(45);
4677                     r[i+46]=av.lane(46);
4678                     r[i+47]=av.lane(47);
4679                     r[i+48]=av.lane(48);
4680                     r[i+49]=av.lane(49);
4681                     r[i+50]=av.lane(50);
4682                     r[i+51]=av.lane(51);
4683                     r[i+52]=av.lane(52);
4684                     r[i+53]=av.lane(53);
4685                     r[i+54]=av.lane(54);
4686                     r[i+55]=av.lane(55);
4687                     r[i+56]=av.lane(56);
4688                     r[i+57]=av.lane(57);
4689                     r[i+58]=av.lane(58);
4690                     r[i+59]=av.lane(59);
4691                     r[i+60]=av.lane(60);
4692                     r[i+61]=av.lane(61);
4693                     r[i+62]=av.lane(62);
4694                     r[i+63]=av.lane(63);
4695                 } else {
4696                     for (int j = 0; j < SPECIES.length(); j++) {
4697                         r[i+j]=av.lane(j);
4698                     }
4699                 }
4700             }
4701         }
4702 
4703         assertArraysEquals(r, a, ByteMaxVectorTests::get);
4704     }
4705 
4706     @Test(dataProvider = "byteUnaryOpProvider")
4707     static void BroadcastByteMaxVectorTests(IntFunction<byte[]> fa) {
4708         byte[] a = fa.apply(SPECIES.length());
4709         byte[] r = new byte[a.length];
4710 
4711         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4712             for (int i = 0; i < a.length; i += SPECIES.length()) {
4713                 ByteVector.broadcast(SPECIES, a[i]).intoArray(r, i);
4714             }
4715         }
4716 
4717         assertBroadcastArraysEquals(r, a);
4718     }
4719 
4720     @Test(dataProvider = "byteUnaryOpProvider")
4721     static void ZeroByteMaxVectorTests(IntFunction<byte[]> fa) {
4722         byte[] a = fa.apply(SPECIES.length());
4723         byte[] r = new byte[a.length];
4724 
4725         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4726             for (int i = 0; i < a.length; i += SPECIES.length()) {
4727                 ByteVector.zero(SPECIES).intoArray(a, i);
4728             }
4729         }
4730 
4731         Assert.assertEquals(a, r);
4732     }
4733 
4734     static byte[] sliceUnary(byte[] a, int origin, int idx) {
4735         byte[] res = new byte[SPECIES.length()];
4736         for (int i = 0; i < SPECIES.length(); i++){
4737             if(i+origin < SPECIES.length())
4738                 res[i] = a[idx+i+origin];
4739             else
4740                 res[i] = (byte)0;
4741         }
4742         return res;
4743     }
4744 
4745     @Test(dataProvider = "byteUnaryOpProvider")
4746     static void sliceUnaryByteMaxVectorTests(IntFunction<byte[]> fa) {
4747         byte[] a = fa.apply(SPECIES.length());
4748         byte[] r = new byte[a.length];
4749         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4750         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4751             for (int i = 0; i < a.length; i += SPECIES.length()) {
4752                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4753                 av.slice(origin).intoArray(r, i);
4754             }
4755         }
4756 
4757         assertArraysEquals(r, a, origin, ByteMaxVectorTests::sliceUnary);
4758     }
4759 
4760     static byte[] sliceBinary(byte[] a, byte[] b, int origin, int idx) {
4761         byte[] res = new byte[SPECIES.length()];
4762         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4763             if(i+origin < SPECIES.length())
4764                 res[i] = a[idx+i+origin];
4765             else {
4766                 res[i] = b[idx+j];
4767                 j++;
4768             }
4769         }
4770         return res;
4771     }
4772 
4773     @Test(dataProvider = "byteBinaryOpProvider")
4774     static void sliceBinaryByteMaxVectorTestsBinary(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4775         byte[] a = fa.apply(SPECIES.length());
4776         byte[] b = fb.apply(SPECIES.length());
4777         byte[] r = new byte[a.length];
4778         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4779         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4780             for (int i = 0; i < a.length; i += SPECIES.length()) {
4781                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4782                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4783                 av.slice(origin, bv).intoArray(r, i);
4784             }
4785         }
4786 
4787         assertArraysEquals(r, a, b, origin, ByteMaxVectorTests::sliceBinary);
4788     }
4789 
4790     static byte[] slice(byte[] a, byte[] b, int origin, boolean[] mask, int idx) {
4791         byte[] res = new byte[SPECIES.length()];
4792         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4793             if(i+origin < SPECIES.length())
4794                 res[i] = mask[i] ? a[idx+i+origin] : (byte)0;
4795             else {
4796                 res[i] = mask[i] ? b[idx+j] : (byte)0;
4797                 j++;
4798             }
4799         }
4800         return res;
4801     }
4802 
4803     @Test(dataProvider = "byteBinaryOpMaskProvider")
4804     static void sliceByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4805     IntFunction<boolean[]> fm) {
4806         byte[] a = fa.apply(SPECIES.length());
4807         byte[] b = fb.apply(SPECIES.length());
4808         boolean[] mask = fm.apply(SPECIES.length());
4809         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4810 
4811         byte[] r = new byte[a.length];
4812         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4813         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4814             for (int i = 0; i < a.length; i += SPECIES.length()) {
4815                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4816                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4817                 av.slice(origin, bv, vmask).intoArray(r, i);
4818             }
4819         }
4820 
4821         assertArraysEquals(r, a, b, origin, mask, ByteMaxVectorTests::slice);
4822     }
4823 
4824     static byte[] unsliceUnary(byte[] a, int origin, int idx) {
4825         byte[] res = new byte[SPECIES.length()];
4826         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4827             if(i < origin)
4828                 res[i] = (byte)0;
4829             else {
4830                 res[i] = a[idx+j];
4831                 j++;
4832             }
4833         }
4834         return res;
4835     }
4836 
4837     @Test(dataProvider = "byteUnaryOpProvider")
4838     static void unsliceUnaryByteMaxVectorTests(IntFunction<byte[]> fa) {
4839         byte[] a = fa.apply(SPECIES.length());
4840         byte[] r = new byte[a.length];
4841         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4842         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4843             for (int i = 0; i < a.length; i += SPECIES.length()) {
4844                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4845                 av.unslice(origin).intoArray(r, i);
4846             }
4847         }
4848 
4849         assertArraysEquals(r, a, origin, ByteMaxVectorTests::unsliceUnary);
4850     }
4851 
4852     static byte[] unsliceBinary(byte[] a, byte[] b, int origin, int part, int idx) {
4853         byte[] res = new byte[SPECIES.length()];
4854         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4855             if (part == 0) {
4856                 if (i < origin)
4857                     res[i] = b[idx+i];
4858                 else {
4859                     res[i] = a[idx+j];
4860                     j++;
4861                 }
4862             } else if (part == 1) {
4863                 if (i < origin)
4864                     res[i] = a[idx+SPECIES.length()-origin+i];
4865                 else {
4866                     res[i] = b[idx+origin+j];
4867                     j++;
4868                 }
4869             }
4870         }
4871         return res;
4872     }
4873 
4874     @Test(dataProvider = "byteBinaryOpProvider")
4875     static void unsliceBinaryByteMaxVectorTestsBinary(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
4876         byte[] a = fa.apply(SPECIES.length());
4877         byte[] b = fb.apply(SPECIES.length());
4878         byte[] r = new byte[a.length];
4879         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4880         int part = (new java.util.Random()).nextInt(2);
4881         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4882             for (int i = 0; i < a.length; i += SPECIES.length()) {
4883                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4884                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4885                 av.unslice(origin, bv, part).intoArray(r, i);
4886             }
4887         }
4888 
4889         assertArraysEquals(r, a, b, origin, part, ByteMaxVectorTests::unsliceBinary);
4890     }
4891 
4892     static byte[] unslice(byte[] a, byte[] b, int origin, int part, boolean[] mask, int idx) {
4893         byte[] res = new byte[SPECIES.length()];
4894         for (int i = 0, j = 0; i < SPECIES.length(); i++){
4895             if(i+origin < SPECIES.length())
4896                 res[i] = b[idx+i+origin];
4897             else {
4898                 res[i] = b[idx+j];
4899                 j++;
4900             }
4901         }
4902         for (int i = 0; i < SPECIES.length(); i++){
4903             res[i] = mask[i] ? a[idx+i] : res[i];
4904         }
4905         byte[] res1 = new byte[SPECIES.length()];
4906         if (part == 0) {
4907             for (int i = 0, j = 0; i < SPECIES.length(); i++){
4908                 if (i < origin)
4909                     res1[i] = b[idx+i];
4910                 else {
4911                    res1[i] = res[j];
4912                    j++;
4913                 }
4914             }
4915         } else if (part == 1) {
4916             for (int i = 0, j = 0; i < SPECIES.length(); i++){
4917                 if (i < origin)
4918                     res1[i] = res[SPECIES.length()-origin+i];
4919                 else {
4920                     res1[i] = b[idx+origin+j];
4921                     j++;
4922                 }
4923             }
4924         }
4925         return res1;
4926     }
4927 
4928     @Test(dataProvider = "byteBinaryOpMaskProvider")
4929     static void unsliceByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4930     IntFunction<boolean[]> fm) {
4931         byte[] a = fa.apply(SPECIES.length());
4932         byte[] b = fb.apply(SPECIES.length());
4933         boolean[] mask = fm.apply(SPECIES.length());
4934         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4935         byte[] r = new byte[a.length];
4936         int origin = (new java.util.Random()).nextInt(SPECIES.length());
4937         int part = (new java.util.Random()).nextInt(2);
4938         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4939             for (int i = 0; i < a.length; i += SPECIES.length()) {
4940                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4941                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4942                 av.unslice(origin, bv, part, vmask).intoArray(r, i);
4943             }
4944         }
4945 
4946         assertArraysEquals(r, a, b, origin, part, mask, ByteMaxVectorTests::unslice);
4947     }
4948 
4949     static byte BITWISE_BLEND(byte a, byte b, byte c) {
4950         return (byte)((a&~(c))|(b&c));
4951     }
4952 
4953     static byte bitwiseBlend(byte a, byte b, byte c) {
4954         return (byte)((a&~(c))|(b&c));
4955     }
4956 
4957     @Test(dataProvider = "byteTernaryOpProvider")
4958     static void BITWISE_BLENDByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
4959         byte[] a = fa.apply(SPECIES.length());
4960         byte[] b = fb.apply(SPECIES.length());
4961         byte[] c = fc.apply(SPECIES.length());
4962         byte[] r = fr.apply(SPECIES.length());
4963 
4964         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4965             for (int i = 0; i < a.length; i += SPECIES.length()) {
4966                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4967                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4968                 ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
4969                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
4970             }
4971         }
4972 
4973         assertArraysEquals(r, a, b, c, ByteMaxVectorTests::BITWISE_BLEND);
4974     }
4975 
4976     @Test(dataProvider = "byteTernaryOpProvider")
4977     static void bitwiseBlendByteMaxVectorTests(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
4978         byte[] a = fa.apply(SPECIES.length());
4979         byte[] b = fb.apply(SPECIES.length());
4980         byte[] c = fc.apply(SPECIES.length());
4981         byte[] r = fr.apply(SPECIES.length());
4982 
4983         for (int i = 0; i < a.length; i += SPECIES.length()) {
4984             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
4985             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
4986             ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
4987             av.bitwiseBlend(bv, cv).intoArray(r, i);
4988         }
4989 
4990         assertArraysEquals(r, a, b, c, ByteMaxVectorTests::bitwiseBlend);
4991     }
4992 
4993     @Test(dataProvider = "byteTernaryOpMaskProvider")
4994     static void BITWISE_BLENDByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
4995                                           IntFunction<byte[]> fc, IntFunction<boolean[]> fm) {
4996         byte[] a = fa.apply(SPECIES.length());
4997         byte[] b = fb.apply(SPECIES.length());
4998         byte[] c = fc.apply(SPECIES.length());
4999         byte[] r = fr.apply(SPECIES.length());
5000         boolean[] mask = fm.apply(SPECIES.length());
5001         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5002 
5003         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5004             for (int i = 0; i < a.length; i += SPECIES.length()) {
5005                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5006                 ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
5007                 ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
5008                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
5009             }
5010         }
5011 
5012         assertArraysEquals(r, a, b, c, mask, ByteMaxVectorTests::BITWISE_BLEND);
5013     }
5014 
5015     @Test(dataProvider = "byteTernaryOpProvider")
5016     static void BITWISE_BLENDByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
5017         byte[] a = fa.apply(SPECIES.length());
5018         byte[] b = fb.apply(SPECIES.length());
5019         byte[] c = fc.apply(SPECIES.length());
5020         byte[] r = fr.apply(SPECIES.length());
5021 
5022         for (int i = 0; i < a.length; i += SPECIES.length()) {
5023             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5024             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
5025             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
5026         }
5027         assertBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::BITWISE_BLEND);
5028     }
5029 
5030     @Test(dataProvider = "byteTernaryOpProvider")
5031     static void BITWISE_BLENDByteMaxVectorTestsAltBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
5032         byte[] a = fa.apply(SPECIES.length());
5033         byte[] b = fb.apply(SPECIES.length());
5034         byte[] c = fc.apply(SPECIES.length());
5035         byte[] r = fr.apply(SPECIES.length());
5036 
5037         for (int i = 0; i < a.length; i += SPECIES.length()) {
5038             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5039             ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
5040             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
5041         }
5042         assertAltBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::BITWISE_BLEND);
5043     }
5044 
5045     @Test(dataProvider = "byteTernaryOpProvider")
5046     static void bitwiseBlendByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
5047         byte[] a = fa.apply(SPECIES.length());
5048         byte[] b = fb.apply(SPECIES.length());
5049         byte[] c = fc.apply(SPECIES.length());
5050         byte[] r = fr.apply(SPECIES.length());
5051 
5052         for (int i = 0; i < a.length; i += SPECIES.length()) {
5053             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5054             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
5055             av.bitwiseBlend(bv, c[i]).intoArray(r, i);
5056         }
5057         assertBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::bitwiseBlend);
5058     }
5059 
5060     @Test(dataProvider = "byteTernaryOpProvider")
5061     static void bitwiseBlendByteMaxVectorTestsAltBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
5062         byte[] a = fa.apply(SPECIES.length());
5063         byte[] b = fb.apply(SPECIES.length());
5064         byte[] c = fc.apply(SPECIES.length());
5065         byte[] r = fr.apply(SPECIES.length());
5066 
5067         for (int i = 0; i < a.length; i += SPECIES.length()) {
5068             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5069             ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
5070             av.bitwiseBlend(b[i], cv).intoArray(r, i);
5071         }
5072         assertAltBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::bitwiseBlend);
5073     }
5074 
5075     @Test(dataProvider = "byteTernaryOpMaskProvider")
5076     static void BITWISE_BLENDByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
5077                                           IntFunction<byte[]> fc, IntFunction<boolean[]> fm) {
5078         byte[] a = fa.apply(SPECIES.length());
5079         byte[] b = fb.apply(SPECIES.length());
5080         byte[] c = fc.apply(SPECIES.length());
5081         byte[] r = fr.apply(SPECIES.length());
5082         boolean[] mask = fm.apply(SPECIES.length());
5083         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5084 
5085         for (int i = 0; i < a.length; i += SPECIES.length()) {
5086             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5087             ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
5088             av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
5089         }
5090 
5091         assertBroadcastArraysEquals(r, a, b, c, mask, ByteMaxVectorTests::BITWISE_BLEND);
5092     }
5093 
5094     @Test(dataProvider = "byteTernaryOpMaskProvider")
5095     static void BITWISE_BLENDByteMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
5096                                           IntFunction<byte[]> fc, IntFunction<boolean[]> fm) {
5097         byte[] a = fa.apply(SPECIES.length());
5098         byte[] b = fb.apply(SPECIES.length());
5099         byte[] c = fc.apply(SPECIES.length());
5100         byte[] r = fr.apply(SPECIES.length());
5101         boolean[] mask = fm.apply(SPECIES.length());
5102         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5103 
5104         for (int i = 0; i < a.length; i += SPECIES.length()) {
5105             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5106             ByteVector cv = ByteVector.fromArray(SPECIES, c, i);
5107             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
5108         }
5109 
5110         assertAltBroadcastArraysEquals(r, a, b, c, mask, ByteMaxVectorTests::BITWISE_BLEND);
5111     }
5112 
5113     @Test(dataProvider = "byteTernaryOpProvider")
5114     static void BITWISE_BLENDByteMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
5115         byte[] a = fa.apply(SPECIES.length());
5116         byte[] b = fb.apply(SPECIES.length());
5117         byte[] c = fc.apply(SPECIES.length());
5118         byte[] r = fr.apply(SPECIES.length());
5119 
5120         for (int i = 0; i < a.length; i += SPECIES.length()) {
5121             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5122             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
5123         }
5124 
5125         assertDoubleBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::BITWISE_BLEND);
5126     }
5127 
5128     @Test(dataProvider = "byteTernaryOpProvider")
5129     static void bitwiseBlendByteMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb, IntFunction<byte[]> fc) {
5130         byte[] a = fa.apply(SPECIES.length());
5131         byte[] b = fb.apply(SPECIES.length());
5132         byte[] c = fc.apply(SPECIES.length());
5133         byte[] r = fr.apply(SPECIES.length());
5134 
5135         for (int i = 0; i < a.length; i += SPECIES.length()) {
5136             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5137             av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
5138         }
5139 
5140         assertDoubleBroadcastArraysEquals(r, a, b, c, ByteMaxVectorTests::bitwiseBlend);
5141     }
5142 
5143     @Test(dataProvider = "byteTernaryOpMaskProvider")
5144     static void BITWISE_BLENDByteMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
5145                                           IntFunction<byte[]> fc, IntFunction<boolean[]> fm) {
5146         byte[] a = fa.apply(SPECIES.length());
5147         byte[] b = fb.apply(SPECIES.length());
5148         byte[] c = fc.apply(SPECIES.length());
5149         byte[] r = fr.apply(SPECIES.length());
5150         boolean[] mask = fm.apply(SPECIES.length());
5151         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5152 
5153         for (int i = 0; i < a.length; i += SPECIES.length()) {
5154             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5155             av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
5156         }
5157 
5158         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ByteMaxVectorTests::BITWISE_BLEND);
5159     }
5160 
5161     static byte NEG(byte a) {
5162         return (byte)(-((byte)a));
5163     }
5164 
5165     static byte neg(byte a) {
5166         return (byte)(-((byte)a));
5167     }
5168 
5169     @Test(dataProvider = "byteUnaryOpProvider")
5170     static void NEGByteMaxVectorTests(IntFunction<byte[]> fa) {
5171         byte[] a = fa.apply(SPECIES.length());
5172         byte[] r = fr.apply(SPECIES.length());
5173 
5174         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5175             for (int i = 0; i < a.length; i += SPECIES.length()) {
5176                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5177                 av.lanewise(VectorOperators.NEG).intoArray(r, i);
5178             }
5179         }
5180 
5181         assertArraysEquals(r, a, ByteMaxVectorTests::NEG);
5182     }
5183 
5184     @Test(dataProvider = "byteUnaryOpProvider")
5185     static void negByteMaxVectorTests(IntFunction<byte[]> fa) {
5186         byte[] a = fa.apply(SPECIES.length());
5187         byte[] r = fr.apply(SPECIES.length());
5188 
5189         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5190             for (int i = 0; i < a.length; i += SPECIES.length()) {
5191                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5192                 av.neg().intoArray(r, i);
5193             }
5194         }
5195 
5196         assertArraysEquals(r, a, ByteMaxVectorTests::neg);
5197     }
5198 
5199     @Test(dataProvider = "byteUnaryOpMaskProvider")
5200     static void NEGMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
5201                                                 IntFunction<boolean[]> fm) {
5202         byte[] a = fa.apply(SPECIES.length());
5203         byte[] r = fr.apply(SPECIES.length());
5204         boolean[] mask = fm.apply(SPECIES.length());
5205         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5206 
5207         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5208             for (int i = 0; i < a.length; i += SPECIES.length()) {
5209                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5210                 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
5211             }
5212         }
5213 
5214         assertArraysEquals(r, a, mask, ByteMaxVectorTests::NEG);
5215     }
5216 
5217     static byte ABS(byte a) {
5218         return (byte)(Math.abs((byte)a));
5219     }
5220 
5221     static byte abs(byte a) {
5222         return (byte)(Math.abs((byte)a));
5223     }
5224 
5225     @Test(dataProvider = "byteUnaryOpProvider")
5226     static void ABSByteMaxVectorTests(IntFunction<byte[]> fa) {
5227         byte[] a = fa.apply(SPECIES.length());
5228         byte[] r = fr.apply(SPECIES.length());
5229 
5230         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5231             for (int i = 0; i < a.length; i += SPECIES.length()) {
5232                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5233                 av.lanewise(VectorOperators.ABS).intoArray(r, i);
5234             }
5235         }
5236 
5237         assertArraysEquals(r, a, ByteMaxVectorTests::ABS);
5238     }
5239 
5240     @Test(dataProvider = "byteUnaryOpProvider")
5241     static void absByteMaxVectorTests(IntFunction<byte[]> fa) {
5242         byte[] a = fa.apply(SPECIES.length());
5243         byte[] r = fr.apply(SPECIES.length());
5244 
5245         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5246             for (int i = 0; i < a.length; i += SPECIES.length()) {
5247                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5248                 av.abs().intoArray(r, i);
5249             }
5250         }
5251 
5252         assertArraysEquals(r, a, ByteMaxVectorTests::abs);
5253     }
5254 
5255     @Test(dataProvider = "byteUnaryOpMaskProvider")
5256     static void ABSMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
5257                                                 IntFunction<boolean[]> fm) {
5258         byte[] a = fa.apply(SPECIES.length());
5259         byte[] r = fr.apply(SPECIES.length());
5260         boolean[] mask = fm.apply(SPECIES.length());
5261         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5262 
5263         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5264             for (int i = 0; i < a.length; i += SPECIES.length()) {
5265                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5266                 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
5267             }
5268         }
5269 
5270         assertArraysEquals(r, a, mask, ByteMaxVectorTests::ABS);
5271     }
5272 
5273     static byte NOT(byte a) {
5274         return (byte)(~((byte)a));
5275     }
5276 
5277     static byte not(byte a) {
5278         return (byte)(~((byte)a));
5279     }
5280 
5281     @Test(dataProvider = "byteUnaryOpProvider")
5282     static void NOTByteMaxVectorTests(IntFunction<byte[]> fa) {
5283         byte[] a = fa.apply(SPECIES.length());
5284         byte[] r = fr.apply(SPECIES.length());
5285 
5286         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5287             for (int i = 0; i < a.length; i += SPECIES.length()) {
5288                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5289                 av.lanewise(VectorOperators.NOT).intoArray(r, i);
5290             }
5291         }
5292 
5293         assertArraysEquals(r, a, ByteMaxVectorTests::NOT);
5294     }
5295 
5296     @Test(dataProvider = "byteUnaryOpProvider")
5297     static void notByteMaxVectorTests(IntFunction<byte[]> fa) {
5298         byte[] a = fa.apply(SPECIES.length());
5299         byte[] r = fr.apply(SPECIES.length());
5300 
5301         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5302             for (int i = 0; i < a.length; i += SPECIES.length()) {
5303                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5304                 av.not().intoArray(r, i);
5305             }
5306         }
5307 
5308         assertArraysEquals(r, a, ByteMaxVectorTests::not);
5309     }
5310 
5311     @Test(dataProvider = "byteUnaryOpMaskProvider")
5312     static void NOTMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
5313                                                 IntFunction<boolean[]> fm) {
5314         byte[] a = fa.apply(SPECIES.length());
5315         byte[] r = fr.apply(SPECIES.length());
5316         boolean[] mask = fm.apply(SPECIES.length());
5317         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5318 
5319         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5320             for (int i = 0; i < a.length; i += SPECIES.length()) {
5321                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5322                 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
5323             }
5324         }
5325 
5326         assertArraysEquals(r, a, mask, ByteMaxVectorTests::NOT);
5327     }
5328 
5329     static byte ZOMO(byte a) {
5330         return (byte)((a==0?0:-1));
5331     }
5332 
5333     @Test(dataProvider = "byteUnaryOpProvider")
5334     static void ZOMOByteMaxVectorTests(IntFunction<byte[]> fa) {
5335         byte[] a = fa.apply(SPECIES.length());
5336         byte[] r = fr.apply(SPECIES.length());
5337 
5338         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5339             for (int i = 0; i < a.length; i += SPECIES.length()) {
5340                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5341                 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
5342             }
5343         }
5344 
5345         assertArraysEquals(r, a, ByteMaxVectorTests::ZOMO);
5346     }
5347 
5348     @Test(dataProvider = "byteUnaryOpMaskProvider")
5349     static void ZOMOMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
5350                                                 IntFunction<boolean[]> fm) {
5351         byte[] a = fa.apply(SPECIES.length());
5352         byte[] r = fr.apply(SPECIES.length());
5353         boolean[] mask = fm.apply(SPECIES.length());
5354         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5355 
5356         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5357             for (int i = 0; i < a.length; i += SPECIES.length()) {
5358                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5359                 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
5360             }
5361         }
5362 
5363         assertArraysEquals(r, a, mask, ByteMaxVectorTests::ZOMO);
5364     }
5365 
5366     static byte BIT_COUNT(byte a) {
5367         return (byte)(Integer.bitCount((int)a & 0xFF));
5368     }
5369 
5370     @Test(dataProvider = "byteUnaryOpProvider")
5371     static void BIT_COUNTByteMaxVectorTests(IntFunction<byte[]> fa) {
5372         byte[] a = fa.apply(SPECIES.length());
5373         byte[] r = fr.apply(SPECIES.length());
5374 
5375         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5376             for (int i = 0; i < a.length; i += SPECIES.length()) {
5377                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5378                 av.lanewise(VectorOperators.BIT_COUNT).intoArray(r, i);
5379             }
5380         }
5381 
5382         assertArraysEquals(r, a, ByteMaxVectorTests::BIT_COUNT);
5383     }
5384 
5385     @Test(dataProvider = "byteUnaryOpMaskProvider")
5386     static void BIT_COUNTMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
5387                                                 IntFunction<boolean[]> fm) {
5388         byte[] a = fa.apply(SPECIES.length());
5389         byte[] r = fr.apply(SPECIES.length());
5390         boolean[] mask = fm.apply(SPECIES.length());
5391         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5392 
5393         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5394             for (int i = 0; i < a.length; i += SPECIES.length()) {
5395                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5396                 av.lanewise(VectorOperators.BIT_COUNT, vmask).intoArray(r, i);
5397             }
5398         }
5399 
5400         assertArraysEquals(r, a, mask, ByteMaxVectorTests::BIT_COUNT);
5401     }
5402 
5403     static byte TRAILING_ZEROS_COUNT(byte a) {
5404         return (byte)(TRAILING_ZEROS_COUNT_scalar(a));
5405     }
5406 
5407     @Test(dataProvider = "byteUnaryOpProvider")
5408     static void TRAILING_ZEROS_COUNTByteMaxVectorTests(IntFunction<byte[]> fa) {
5409         byte[] a = fa.apply(SPECIES.length());
5410         byte[] r = fr.apply(SPECIES.length());
5411 
5412         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5413             for (int i = 0; i < a.length; i += SPECIES.length()) {
5414                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5415                 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT).intoArray(r, i);
5416             }
5417         }
5418 
5419         assertArraysEquals(r, a, ByteMaxVectorTests::TRAILING_ZEROS_COUNT);
5420     }
5421 
5422     @Test(dataProvider = "byteUnaryOpMaskProvider")
5423     static void TRAILING_ZEROS_COUNTMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
5424                                                 IntFunction<boolean[]> fm) {
5425         byte[] a = fa.apply(SPECIES.length());
5426         byte[] r = fr.apply(SPECIES.length());
5427         boolean[] mask = fm.apply(SPECIES.length());
5428         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5429 
5430         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5431             for (int i = 0; i < a.length; i += SPECIES.length()) {
5432                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5433                 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT, vmask).intoArray(r, i);
5434             }
5435         }
5436 
5437         assertArraysEquals(r, a, mask, ByteMaxVectorTests::TRAILING_ZEROS_COUNT);
5438     }
5439 
5440     static byte LEADING_ZEROS_COUNT(byte a) {
5441         return (byte)(LEADING_ZEROS_COUNT_scalar(a));
5442     }
5443 
5444     @Test(dataProvider = "byteUnaryOpProvider")
5445     static void LEADING_ZEROS_COUNTByteMaxVectorTests(IntFunction<byte[]> fa) {
5446         byte[] a = fa.apply(SPECIES.length());
5447         byte[] r = fr.apply(SPECIES.length());
5448 
5449         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5450             for (int i = 0; i < a.length; i += SPECIES.length()) {
5451                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5452                 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT).intoArray(r, i);
5453             }
5454         }
5455 
5456         assertArraysEquals(r, a, ByteMaxVectorTests::LEADING_ZEROS_COUNT);
5457     }
5458 
5459     @Test(dataProvider = "byteUnaryOpMaskProvider")
5460     static void LEADING_ZEROS_COUNTMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
5461                                                 IntFunction<boolean[]> fm) {
5462         byte[] a = fa.apply(SPECIES.length());
5463         byte[] r = fr.apply(SPECIES.length());
5464         boolean[] mask = fm.apply(SPECIES.length());
5465         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5466 
5467         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5468             for (int i = 0; i < a.length; i += SPECIES.length()) {
5469                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5470                 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT, vmask).intoArray(r, i);
5471             }
5472         }
5473 
5474         assertArraysEquals(r, a, mask, ByteMaxVectorTests::LEADING_ZEROS_COUNT);
5475     }
5476 
5477     static byte REVERSE(byte a) {
5478         return (byte)(REVERSE_scalar(a));
5479     }
5480 
5481     @Test(dataProvider = "byteUnaryOpProvider")
5482     static void REVERSEByteMaxVectorTests(IntFunction<byte[]> fa) {
5483         byte[] a = fa.apply(SPECIES.length());
5484         byte[] r = fr.apply(SPECIES.length());
5485 
5486         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5487             for (int i = 0; i < a.length; i += SPECIES.length()) {
5488                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5489                 av.lanewise(VectorOperators.REVERSE).intoArray(r, i);
5490             }
5491         }
5492 
5493         assertArraysEquals(r, a, ByteMaxVectorTests::REVERSE);
5494     }
5495 
5496     @Test(dataProvider = "byteUnaryOpMaskProvider")
5497     static void REVERSEMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
5498                                                 IntFunction<boolean[]> fm) {
5499         byte[] a = fa.apply(SPECIES.length());
5500         byte[] r = fr.apply(SPECIES.length());
5501         boolean[] mask = fm.apply(SPECIES.length());
5502         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5503 
5504         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5505             for (int i = 0; i < a.length; i += SPECIES.length()) {
5506                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5507                 av.lanewise(VectorOperators.REVERSE, vmask).intoArray(r, i);
5508             }
5509         }
5510 
5511         assertArraysEquals(r, a, mask, ByteMaxVectorTests::REVERSE);
5512     }
5513 
5514     static byte REVERSE_BYTES(byte a) {
5515         return (byte)(a);
5516     }
5517 
5518     @Test(dataProvider = "byteUnaryOpProvider")
5519     static void REVERSE_BYTESByteMaxVectorTests(IntFunction<byte[]> fa) {
5520         byte[] a = fa.apply(SPECIES.length());
5521         byte[] r = fr.apply(SPECIES.length());
5522 
5523         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5524             for (int i = 0; i < a.length; i += SPECIES.length()) {
5525                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5526                 av.lanewise(VectorOperators.REVERSE_BYTES).intoArray(r, i);
5527             }
5528         }
5529 
5530         assertArraysEquals(r, a, ByteMaxVectorTests::REVERSE_BYTES);
5531     }
5532 
5533     @Test(dataProvider = "byteUnaryOpMaskProvider")
5534     static void REVERSE_BYTESMaskedByteMaxVectorTests(IntFunction<byte[]> fa,
5535                                                 IntFunction<boolean[]> fm) {
5536         byte[] a = fa.apply(SPECIES.length());
5537         byte[] r = fr.apply(SPECIES.length());
5538         boolean[] mask = fm.apply(SPECIES.length());
5539         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5540 
5541         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5542             for (int i = 0; i < a.length; i += SPECIES.length()) {
5543                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5544                 av.lanewise(VectorOperators.REVERSE_BYTES, vmask).intoArray(r, i);
5545             }
5546         }
5547 
5548         assertArraysEquals(r, a, mask, ByteMaxVectorTests::REVERSE_BYTES);
5549     }
5550 
5551     @Test(dataProvider = "byteCompareOpProvider")
5552     static void ltByteMaxVectorTestsBroadcastSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
5553         byte[] a = fa.apply(SPECIES.length());
5554         byte[] b = fb.apply(SPECIES.length());
5555 
5556         for (int i = 0; i < a.length; i += SPECIES.length()) {
5557             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5558             VectorMask<Byte> mv = av.lt(b[i]);
5559 
5560             // Check results as part of computation.
5561             for (int j = 0; j < SPECIES.length(); j++) {
5562                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
5563             }
5564         }
5565     }
5566 
5567     @Test(dataProvider = "byteCompareOpProvider")
5568     static void eqByteMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb) {
5569         byte[] a = fa.apply(SPECIES.length());
5570         byte[] b = fb.apply(SPECIES.length());
5571 
5572         for (int i = 0; i < a.length; i += SPECIES.length()) {
5573             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5574             VectorMask<Byte> mv = av.eq(b[i]);
5575 
5576             // Check results as part of computation.
5577             for (int j = 0; j < SPECIES.length(); j++) {
5578                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
5579             }
5580         }
5581     }
5582 
5583     @Test(dataProvider = "byteUnaryOpProvider")
5584     static void toIntArrayByteMaxVectorTestsSmokeTest(IntFunction<byte[]> fa) {
5585         byte[] a = fa.apply(SPECIES.length());
5586 
5587         for (int i = 0; i < a.length; i += SPECIES.length()) {
5588             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5589             int[] r = av.toIntArray();
5590             assertArraysEquals(r, a, i);
5591         }
5592     }
5593 
5594     @Test(dataProvider = "byteUnaryOpProvider")
5595     static void toLongArrayByteMaxVectorTestsSmokeTest(IntFunction<byte[]> fa) {
5596         byte[] a = fa.apply(SPECIES.length());
5597 
5598         for (int i = 0; i < a.length; i += SPECIES.length()) {
5599             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5600             long[] r = av.toLongArray();
5601             assertArraysEquals(r, a, i);
5602         }
5603     }
5604 
5605     @Test(dataProvider = "byteUnaryOpProvider")
5606     static void toDoubleArrayByteMaxVectorTestsSmokeTest(IntFunction<byte[]> fa) {
5607         byte[] a = fa.apply(SPECIES.length());
5608 
5609         for (int i = 0; i < a.length; i += SPECIES.length()) {
5610             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5611             double[] r = av.toDoubleArray();
5612             assertArraysEquals(r, a, i);
5613         }
5614     }
5615 
5616     @Test(dataProvider = "byteUnaryOpProvider")
5617     static void toStringByteMaxVectorTestsSmokeTest(IntFunction<byte[]> fa) {
5618         byte[] a = fa.apply(SPECIES.length());
5619 
5620         for (int i = 0; i < a.length; i += SPECIES.length()) {
5621             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5622             String str = av.toString();
5623 
5624             byte subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5625             Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5626         }
5627     }
5628 
5629     @Test(dataProvider = "byteUnaryOpProvider")
5630     static void hashCodeByteMaxVectorTestsSmokeTest(IntFunction<byte[]> fa) {
5631         byte[] a = fa.apply(SPECIES.length());
5632 
5633         for (int i = 0; i < a.length; i += SPECIES.length()) {
5634             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5635             int hash = av.hashCode();
5636 
5637             byte subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5638             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5639             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5640         }
5641     }
5642 
5643     @Test(dataProvider = "byteUnaryOpProvider")
5644     static void reinterpretAsBytesByteMaxVectorTestsSmokeTest(IntFunction<byte[]> fa) {
5645         byte[] a = fa.apply(SPECIES.length());
5646         byte[] r = new byte[a.length];
5647 
5648         for (int i = 0; i < a.length; i += SPECIES.length()) {
5649             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5650             av.reinterpretAsBytes().intoArray(r, i);
5651         }
5652         assertArraysEquals(r, a, 0);
5653     }
5654 
5655     static long ADDReduceLong(byte[] a, int idx) {
5656         byte res = 0;
5657         for (int i = idx; i < (idx + SPECIES.length()); i++) {
5658             res += a[i];
5659         }
5660 
5661         return (long)res;
5662     }
5663 
5664     static long ADDReduceAllLong(byte[] a) {
5665         long res = 0;
5666         for (int i = 0; i < a.length; i += SPECIES.length()) {
5667             res += ADDReduceLong(a, i);
5668         }
5669 
5670         return res;
5671     }
5672 
5673     @Test(dataProvider = "byteUnaryOpProvider")
5674     static void ADDReduceLongByteMaxVectorTests(IntFunction<byte[]> fa) {
5675         byte[] a = fa.apply(SPECIES.length());
5676         long[] r = lfr.apply(SPECIES.length());
5677         long ra = 0;
5678 
5679         for (int i = 0; i < a.length; i += SPECIES.length()) {
5680             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5681             r[i] = av.reduceLanesToLong(VectorOperators.ADD);
5682         }
5683 
5684         ra = 0;
5685         for (int i = 0; i < a.length; i ++) {
5686             ra += r[i];
5687         }
5688 
5689         assertReductionLongArraysEquals(r, ra, a,
5690                 ByteMaxVectorTests::ADDReduceLong, ByteMaxVectorTests::ADDReduceAllLong);
5691     }
5692 
5693     static long ADDReduceLongMasked(byte[] a, int idx, boolean[] mask) {
5694         byte res = 0;
5695         for (int i = idx; i < (idx + SPECIES.length()); i++) {
5696             if(mask[i % SPECIES.length()])
5697                 res += a[i];
5698         }
5699 
5700         return (long)res;
5701     }
5702 
5703     static long ADDReduceAllLongMasked(byte[] a, boolean[] mask) {
5704         long res = 0;
5705         for (int i = 0; i < a.length; i += SPECIES.length()) {
5706             res += ADDReduceLongMasked(a, i, mask);
5707         }
5708 
5709         return res;
5710     }
5711 
5712     @Test(dataProvider = "byteUnaryOpMaskProvider")
5713     static void ADDReduceLongByteMaxVectorTestsMasked(IntFunction<byte[]> fa, IntFunction<boolean[]> fm) {
5714         byte[] a = fa.apply(SPECIES.length());
5715         long[] r = lfr.apply(SPECIES.length());
5716         boolean[] mask = fm.apply(SPECIES.length());
5717         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5718         long ra = 0;
5719 
5720         for (int i = 0; i < a.length; i += SPECIES.length()) {
5721             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5722             r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
5723         }
5724 
5725         ra = 0;
5726         for (int i = 0; i < a.length; i ++) {
5727             ra += r[i];
5728         }
5729 
5730         assertReductionLongArraysEqualsMasked(r, ra, a, mask,
5731                 ByteMaxVectorTests::ADDReduceLongMasked, ByteMaxVectorTests::ADDReduceAllLongMasked);
5732     }
5733 
5734     @Test(dataProvider = "byteUnaryOpProvider")
5735     static void BroadcastLongByteMaxVectorTestsSmokeTest(IntFunction<byte[]> fa) {
5736         byte[] a = fa.apply(SPECIES.length());
5737         byte[] r = new byte[a.length];
5738 
5739         for (int i = 0; i < a.length; i += SPECIES.length()) {
5740             ByteVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
5741         }
5742         assertBroadcastArraysEquals(r, a);
5743     }
5744 
5745     @Test(dataProvider = "byteBinaryOpMaskProvider")
5746     static void blendByteMaxVectorTestsBroadcastLongSmokeTest(IntFunction<byte[]> fa, IntFunction<byte[]> fb,
5747                                           IntFunction<boolean[]> fm) {
5748         byte[] a = fa.apply(SPECIES.length());
5749         byte[] b = fb.apply(SPECIES.length());
5750         byte[] r = fr.apply(SPECIES.length());
5751         boolean[] mask = fm.apply(SPECIES.length());
5752         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5753 
5754         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5755             for (int i = 0; i < a.length; i += SPECIES.length()) {
5756                 ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5757                 av.blend((long)b[i], vmask).intoArray(r, i);
5758             }
5759         }
5760         assertBroadcastLongArraysEquals(r, a, b, mask, ByteMaxVectorTests::blend);
5761     }
5762 
5763 
5764     @Test(dataProvider = "byteUnaryOpSelectFromProvider")
5765     static void SelectFromByteMaxVectorTests(IntFunction<byte[]> fa,
5766                                            BiFunction<Integer,Integer,byte[]> fs) {
5767         byte[] a = fa.apply(SPECIES.length());
5768         byte[] order = fs.apply(a.length, SPECIES.length());
5769         byte[] r = fr.apply(SPECIES.length());
5770 
5771         for (int i = 0; i < a.length; i += SPECIES.length()) {
5772             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5773             ByteVector bv = ByteVector.fromArray(SPECIES, order, i);
5774             bv.selectFrom(av).intoArray(r, i);
5775         }
5776 
5777         assertSelectFromArraysEquals(r, a, order, SPECIES.length());
5778     }
5779 
5780     @Test(dataProvider = "byteUnaryOpSelectFromMaskProvider")
5781     static void SelectFromByteMaxVectorTestsMaskedSmokeTest(IntFunction<byte[]> fa,
5782                                                            BiFunction<Integer,Integer,byte[]> fs,
5783                                                            IntFunction<boolean[]> fm) {
5784         byte[] a = fa.apply(SPECIES.length());
5785         byte[] order = fs.apply(a.length, SPECIES.length());
5786         byte[] r = fr.apply(SPECIES.length());
5787         boolean[] mask = fm.apply(SPECIES.length());
5788         VectorMask<Byte> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5789 
5790         for (int i = 0; i < a.length; i += SPECIES.length()) {
5791             ByteVector av = ByteVector.fromArray(SPECIES, a, i);
5792             ByteVector bv = ByteVector.fromArray(SPECIES, order, i);
5793             bv.selectFrom(av, vmask).intoArray(r, i);
5794         }
5795 
5796         assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
5797     }
5798 
5799     @Test(dataProvider = "shuffleProvider")
5800     static void shuffleMiscellaneousByteMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5801         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5802 
5803         for (int i = 0; i < a.length; i += SPECIES.length()) {
5804             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5805             int hash = shuffle.hashCode();
5806             int length = shuffle.length();
5807 
5808             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5809             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5810             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5811             Assert.assertEquals(length, SPECIES.length());
5812         }
5813     }
5814 
5815     @Test(dataProvider = "shuffleProvider")
5816     static void shuffleToStringByteMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5817         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5818 
5819         for (int i = 0; i < a.length; i += SPECIES.length()) {
5820             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5821             String str = shuffle.toString();
5822 
5823             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5824             Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
5825                 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5826         }
5827     }
5828 
5829     @Test(dataProvider = "shuffleCompareOpProvider")
5830     static void shuffleEqualsByteMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
5831         int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5832         int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5833 
5834         for (int i = 0; i < a.length; i += SPECIES.length()) {
5835             var av = VectorShuffle.fromArray(SPECIES, a, i);
5836             var bv = VectorShuffle.fromArray(SPECIES, b, i);
5837             boolean eq = av.equals(bv);
5838             int to = i + SPECIES.length();
5839             Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
5840         }
5841     }
5842 
5843     @Test(dataProvider = "maskCompareOpProvider")
5844     static void maskEqualsByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5845         boolean[] a = fa.apply(SPECIES.length());
5846         boolean[] b = fb.apply(SPECIES.length());
5847 
5848         for (int i = 0; i < a.length; i += SPECIES.length()) {
5849             var av = SPECIES.loadMask(a, i);
5850             var bv = SPECIES.loadMask(b, i);
5851             boolean equals = av.equals(bv);
5852             int to = i + SPECIES.length();
5853             Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
5854         }
5855     }
5856 
5857     static boolean beq(boolean a, boolean b) {
5858         return (a == b);
5859     }
5860 
5861     @Test(dataProvider = "maskCompareOpProvider")
5862     static void maskEqByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5863         boolean[] a = fa.apply(SPECIES.length());
5864         boolean[] b = fb.apply(SPECIES.length());
5865         boolean[] r = new boolean[a.length];
5866 
5867         for (int i = 0; i < a.length; i += SPECIES.length()) {
5868             var av = SPECIES.loadMask(a, i);
5869             var bv = SPECIES.loadMask(b, i);
5870             var cv = av.eq(bv);
5871             cv.intoArray(r, i);
5872         }
5873         assertArraysEquals(r, a, b, ByteMaxVectorTests::beq);
5874     }
5875 
5876     @Test(dataProvider = "maskProvider")
5877     static void maskHashCodeByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5878         boolean[] a = fa.apply(SPECIES.length());
5879 
5880         for (int i = 0; i < a.length; i += SPECIES.length()) {
5881             var vmask = SPECIES.loadMask(a, i);
5882             int hash = vmask.hashCode();
5883 
5884             boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5885             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5886             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5887         }
5888     }
5889 
5890     static int maskTrueCount(boolean[] a, int idx) {
5891         int trueCount = 0;
5892         for (int i = idx; i < idx + SPECIES.length(); i++) {
5893             trueCount += a[i] ? 1 : 0;
5894         }
5895         return trueCount;
5896     }
5897 
5898     @Test(dataProvider = "maskProvider")
5899     static void maskTrueCountByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5900         boolean[] a = fa.apply(SPECIES.length());
5901         int[] r = new int[a.length];
5902 
5903         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5904             for (int i = 0; i < a.length; i += SPECIES.length()) {
5905                 var vmask = SPECIES.loadMask(a, i);
5906                 r[i] = vmask.trueCount();
5907             }
5908         }
5909 
5910         assertMaskReductionArraysEquals(r, a, ByteMaxVectorTests::maskTrueCount);
5911     }
5912 
5913     static int maskLastTrue(boolean[] a, int idx) {
5914         int i = idx + SPECIES.length() - 1;
5915         for (; i >= idx; i--) {
5916             if (a[i]) {
5917                 break;
5918             }
5919         }
5920         return i - idx;
5921     }
5922 
5923     @Test(dataProvider = "maskProvider")
5924     static void maskLastTrueByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5925         boolean[] a = fa.apply(SPECIES.length());
5926         int[] r = new int[a.length];
5927 
5928         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5929             for (int i = 0; i < a.length; i += SPECIES.length()) {
5930                 var vmask = SPECIES.loadMask(a, i);
5931                 r[i] = vmask.lastTrue();
5932             }
5933         }
5934 
5935         assertMaskReductionArraysEquals(r, a, ByteMaxVectorTests::maskLastTrue);
5936     }
5937 
5938     static int maskFirstTrue(boolean[] a, int idx) {
5939         int i = idx;
5940         for (; i < idx + SPECIES.length(); i++) {
5941             if (a[i]) {
5942                 break;
5943             }
5944         }
5945         return i - idx;
5946     }
5947 
5948     @Test(dataProvider = "maskProvider")
5949     static void maskFirstTrueByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5950         boolean[] a = fa.apply(SPECIES.length());
5951         int[] r = new int[a.length];
5952 
5953         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5954             for (int i = 0; i < a.length; i += SPECIES.length()) {
5955                 var vmask = SPECIES.loadMask(a, i);
5956                 r[i] = vmask.firstTrue();
5957             }
5958         }
5959 
5960         assertMaskReductionArraysEquals(r, a, ByteMaxVectorTests::maskFirstTrue);
5961     }
5962 
5963     @Test(dataProvider = "maskProvider")
5964     static void maskCompressByteMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5965         int trueCount = 0;
5966         boolean[] a = fa.apply(SPECIES.length());
5967 
5968         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5969             for (int i = 0; i < a.length; i += SPECIES.length()) {
5970                 var vmask = SPECIES.loadMask(a, i);
5971                 trueCount = vmask.trueCount();
5972                 var rmask = vmask.compress();
5973                 for (int j = 0; j < SPECIES.length(); j++)  {
5974                     Assert.assertEquals(rmask.laneIsSet(j), j < trueCount);
5975                 }
5976             }
5977         }
5978     }
5979 
5980 
5981     @DataProvider
5982     public static Object[][] offsetProvider() {
5983         return new Object[][]{
5984                 {0},
5985                 {-1},
5986                 {+1},
5987                 {+2},
5988                 {-2},
5989         };
5990     }
5991 
5992     @Test(dataProvider = "offsetProvider")
5993     static void indexInRangeByteMaxVectorTestsSmokeTest(int offset) {
5994         int limit = SPECIES.length() * BUFFER_REPS;
5995         for (int i = 0; i < limit; i += SPECIES.length()) {
5996             var actualMask = SPECIES.indexInRange(i + offset, limit);
5997             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5998             assert(actualMask.equals(expectedMask));
5999             for (int j = 0; j < SPECIES.length(); j++)  {
6000                 int index = i + j + offset;
6001                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
6002             }
6003         }
6004     }
6005 
6006     @Test(dataProvider = "offsetProvider")
6007     static void indexInRangeLongByteMaxVectorTestsSmokeTest(int offset) {
6008         long limit = SPECIES.length() * BUFFER_REPS;
6009         for (long i = 0; i < limit; i += SPECIES.length()) {
6010             var actualMask = SPECIES.indexInRange(i + offset, limit);
6011             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
6012             assert(actualMask.equals(expectedMask));
6013             for (int j = 0; j < SPECIES.length(); j++)  {
6014                 long index = i + j + offset;
6015                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
6016             }
6017         }
6018     }
6019 
6020     @DataProvider
6021     public static Object[][] lengthProvider() {
6022         return new Object[][]{
6023                 {0},
6024                 {1},
6025                 {32},
6026                 {37},
6027                 {1024},
6028                 {1024+1},
6029                 {1024+5},
6030         };
6031     }
6032 
6033     @Test(dataProvider = "lengthProvider")
6034     static void loopBoundByteMaxVectorTestsSmokeTest(int length) {
6035         int actualLoopBound = SPECIES.loopBound(length);
6036         int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
6037         Assert.assertEquals(actualLoopBound, expectedLoopBound);
6038     }
6039 
6040     @Test(dataProvider = "lengthProvider")
6041     static void loopBoundLongByteMaxVectorTestsSmokeTest(int _length) {
6042         long length = _length;
6043         long actualLoopBound = SPECIES.loopBound(length);
6044         long expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
6045         Assert.assertEquals(actualLoopBound, expectedLoopBound);
6046     }
6047 
6048     @Test
6049     static void ElementSizeByteMaxVectorTestsSmokeTest() {
6050         ByteVector av = ByteVector.zero(SPECIES);
6051         int elsize = av.elementSize();
6052         Assert.assertEquals(elsize, Byte.SIZE);
6053     }
6054 
6055     @Test
6056     static void VectorShapeByteMaxVectorTestsSmokeTest() {
6057         ByteVector av = ByteVector.zero(SPECIES);
6058         VectorShape vsh = av.shape();
6059         assert(vsh.equals(VectorShape.S_Max_BIT));
6060     }
6061 
6062     @Test
6063     static void ShapeWithLanesByteMaxVectorTestsSmokeTest() {
6064         ByteVector av = ByteVector.zero(SPECIES);
6065         VectorShape vsh = av.shape();
6066         VectorSpecies species = vsh.withLanes(byte.class);
6067         assert(species.equals(SPECIES));
6068     }
6069 
6070     @Test
6071     static void ElementTypeByteMaxVectorTestsSmokeTest() {
6072         ByteVector av = ByteVector.zero(SPECIES);
6073         assert(av.species().elementType() == byte.class);
6074     }
6075 
6076     @Test
6077     static void SpeciesElementSizeByteMaxVectorTestsSmokeTest() {
6078         ByteVector av = ByteVector.zero(SPECIES);
6079         assert(av.species().elementSize() == Byte.SIZE);
6080     }
6081 
6082     @Test
6083     static void VectorTypeByteMaxVectorTestsSmokeTest() {
6084         ByteVector av = ByteVector.zero(SPECIES);
6085         assert(av.species().vectorType() == av.getClass());
6086     }
6087 
6088     @Test
6089     static void WithLanesByteMaxVectorTestsSmokeTest() {
6090         ByteVector av = ByteVector.zero(SPECIES);
6091         VectorSpecies species = av.species().withLanes(byte.class);
6092         assert(species.equals(SPECIES));
6093     }
6094 
6095     @Test
6096     static void WithShapeByteMaxVectorTestsSmokeTest() {
6097         ByteVector av = ByteVector.zero(SPECIES);
6098         VectorShape vsh = av.shape();
6099         VectorSpecies species = av.species().withShape(vsh);
6100         assert(species.equals(SPECIES));
6101     }
6102 
6103     @Test
6104     static void MaskAllTrueByteMaxVectorTestsSmokeTest() {
6105         for (int ic = 0; ic < INVOC_COUNT; ic++) {
6106           Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
6107         }
6108     }
6109 }