1 
  2     @Test(dataProvider = "$type$CompareOpProvider")
  3     static void lt$vectorteststype$BroadcastSmokeTest(IntFunction<$type$[]> fa, IntFunction<$type$[]> fb) {
  4         $type$[] a = fa.apply(SPECIES.length());
  5         $type$[] b = fb.apply(SPECIES.length());
  6 
  7         for (int i = 0; i < a.length; i += SPECIES.length()) {
  8             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
  9             VectorMask<$Wideboxtype$> mv = av.lt(b[i]);
 10 
 11             // Check results as part of computation.
 12             for (int j = 0; j < SPECIES.length(); j++) {
 13                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
 14             }
 15         }
 16     }
 17 
 18     @Test(dataProvider = "$type$CompareOpProvider")
 19     static void eq$vectorteststype$BroadcastMaskedSmokeTest(IntFunction<$type$[]> fa, IntFunction<$type$[]> fb) {
 20         $type$[] a = fa.apply(SPECIES.length());
 21         $type$[] b = fb.apply(SPECIES.length());
 22 
 23         for (int i = 0; i < a.length; i += SPECIES.length()) {
 24             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
 25             VectorMask<$Wideboxtype$> mv = av.eq(b[i]);
 26 
 27             // Check results as part of computation.
 28             for (int j = 0; j < SPECIES.length(); j++) {
 29                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
 30             }
 31         }
 32     }
 33 
 34 #if[byteOrShort]
 35     @Test(dataProvider = "$type$UnaryOpProvider")
 36 #else[byteOrShort]
 37 #if[Int]
 38     @Test(dataProvider = "$type$UnaryOpProvider")
 39 #else[Int]
 40     @Test(dataProvider = "$type$toIntUnaryOpProvider")
 41 #end[Int]
 42 #end[byteOrShort]
 43     static void toIntArray$vectorteststype$SmokeTest(IntFunction<$type$[]> fa) {
 44         $type$[] a = fa.apply(SPECIES.length());
 45 
 46         for (int i = 0; i < a.length; i += SPECIES.length()) {
 47             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
 48             int[] r = av.toIntArray();
 49             assertArraysEquals(r, a, i);
 50         }
 51     }
 52 
 53 #if[FP]
 54     @Test(dataProvider = "$type$toLongUnaryOpProvider")
 55 #else[FP]
 56     @Test(dataProvider = "$type$UnaryOpProvider")
 57 #end[FP]
 58     static void toLongArray$vectorteststype$SmokeTest(IntFunction<$type$[]> fa) {
 59         $type$[] a = fa.apply(SPECIES.length());
 60 
 61         for (int i = 0; i < a.length; i += SPECIES.length()) {
 62             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
 63             long[] r = av.toLongArray();
 64             assertArraysEquals(r, a, i);
 65         }
 66     }
 67 
 68 #if[!Double]
 69     @Test(dataProvider = "$type$UnaryOpProvider")
 70     static void toDoubleArray$vectorteststype$SmokeTest(IntFunction<$type$[]> fa) {
 71         $type$[] a = fa.apply(SPECIES.length());
 72 
 73         for (int i = 0; i < a.length; i += SPECIES.length()) {
 74             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
 75             double[] r = av.toDoubleArray();
 76             assertArraysEquals(r, a, i);
 77         }
 78     }
 79 #end[!Double]
 80 
 81     @Test(dataProvider = "$type$UnaryOpProvider")
 82     static void toString$vectorteststype$SmokeTest(IntFunction<$type$[]> fa) {
 83         $type$[] a = fa.apply(SPECIES.length());
 84 
 85         for (int i = 0; i < a.length; i += SPECIES.length()) {
 86             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
 87             String str = av.toString();
 88 
 89             $type$ subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
 90             Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
 91         }
 92     }
 93 
 94     @Test(dataProvider = "$type$UnaryOpProvider")
 95     static void hashCode$vectorteststype$SmokeTest(IntFunction<$type$[]> fa) {
 96         $type$[] a = fa.apply(SPECIES.length());
 97 
 98         for (int i = 0; i < a.length; i += SPECIES.length()) {
 99             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
100             int hash = av.hashCode();
101 
102             $type$ subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
103             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
104             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
105         }
106     }
107 
108 #if[byte]
109     @Test(dataProvider = "$type$UnaryOpProvider")
110     static void reinterpretAsBytes$vectorteststype$SmokeTest(IntFunction<$type$[]> fa) {
111         $type$[] a = fa.apply(SPECIES.length());
112         $type$[] r = new $type$[a.length];
113 
114         for (int i = 0; i < a.length; i += SPECIES.length()) {
115             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
116             av.reinterpretAsBytes().intoArray(r, i);
117         }
118         assertArraysEquals(r, a, 0);
119     }
120 #end[byte]
121 
122 #if[!Long]
123     static long ADDReduceLong($type$[] a, int idx) {
124         $type$ res = 0;
125         for (int i = idx; i < (idx + SPECIES.length()); i++) {
126             res += a[i];
127         }
128 
129         return (long)res;
130     }
131 
132     static long ADDReduceAllLong($type$[] a) {
133         long res = 0;
134         for (int i = 0; i < a.length; i += SPECIES.length()) {
135             res += ADDReduceLong(a, i);
136         }
137 
138         return res;
139     }
140 
141     @Test(dataProvider = "$type$UnaryOpProvider")
142     static void ADDReduceLong$vectorteststype$(IntFunction<$type$[]> fa) {
143         $type$[] a = fa.apply(SPECIES.length());
144         long[] r = lfr.apply(SPECIES.length());
145         long ra = 0;
146 
147         for (int i = 0; i < a.length; i += SPECIES.length()) {
148             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
149             r[i] = av.reduceLanesToLong(VectorOperators.ADD);
150         }
151 
152         ra = 0;
153         for (int i = 0; i < a.length; i ++) {
154             ra += r[i];
155         }
156 
157         assertReductionLongArraysEquals(r, ra, a,
158                 $vectorteststype$::ADDReduceLong, $vectorteststype$::ADDReduceAllLong);
159     }
160 
161     static long ADDReduceLongMasked($type$[] a, int idx, boolean[] mask) {
162         $type$ res = 0;
163         for (int i = idx; i < (idx + SPECIES.length()); i++) {
164             if(mask[i % SPECIES.length()])
165                 res += a[i];
166         }
167 
168         return (long)res;
169     }
170 
171     static long ADDReduceAllLongMasked($type$[] a, boolean[] mask) {
172         long res = 0;
173         for (int i = 0; i < a.length; i += SPECIES.length()) {
174             res += ADDReduceLongMasked(a, i, mask);
175         }
176 
177         return res;
178     }
179 
180     @Test(dataProvider = "$type$UnaryOpMaskProvider")
181     static void ADDReduceLong$vectorteststype$Masked(IntFunction<$type$[]> fa, IntFunction<boolean[]> fm) {
182         $type$[] a = fa.apply(SPECIES.length());
183         long[] r = lfr.apply(SPECIES.length());
184         boolean[] mask = fm.apply(SPECIES.length());
185         VectorMask<$Wideboxtype$> vmask = VectorMask.fromArray(SPECIES, mask, 0);
186         long ra = 0;
187 
188         for (int i = 0; i < a.length; i += SPECIES.length()) {
189             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
190             r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
191         }
192 
193         ra = 0;
194         for (int i = 0; i < a.length; i ++) {
195             ra += r[i];
196         }
197 
198         assertReductionLongArraysEqualsMasked(r, ra, a, mask,
199                 $vectorteststype$::ADDReduceLongMasked, $vectorteststype$::ADDReduceAllLongMasked);
200     }
201 
202 #if[FP]
203     @Test(dataProvider = "$type$toLongUnaryOpProvider")
204 #else[FP]
205     @Test(dataProvider = "$type$UnaryOpProvider")
206 #end[FP]
207     static void BroadcastLong$vectorteststype$SmokeTest(IntFunction<$type$[]> fa) {
208         $type$[] a = fa.apply(SPECIES.length());
209         $type$[] r = new $type$[a.length];
210 
211         for (int i = 0; i < a.length; i += SPECIES.length()) {
212             $abstractvectortype$.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
213         }
214         assertBroadcastArraysEquals(r, a);
215     }
216 
217     @Test(dataProvider = "$type$BinaryOpMaskProvider")
218     static void blend$vectorteststype$BroadcastLongSmokeTest(IntFunction<$type$[]> fa, IntFunction<$type$[]> fb,
219                                           IntFunction<boolean[]> fm) {
220         $type$[] a = fa.apply(SPECIES.length());
221         $type$[] b = fb.apply(SPECIES.length());
222         $type$[] r = fr.apply(SPECIES.length());
223         boolean[] mask = fm.apply(SPECIES.length());
224         VectorMask<$Wideboxtype$> vmask = VectorMask.fromArray(SPECIES, mask, 0);
225 
226         for (int ic = 0; ic < INVOC_COUNT; ic++) {
227             for (int i = 0; i < a.length; i += SPECIES.length()) {
228                 $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
229                 av.blend((long)b[i], vmask).intoArray(r, i);
230             }
231         }
232         assertBroadcastLongArraysEquals(r, a, b, mask, $vectorteststype$::blend);
233     }
234 #end[!Long]
235 
236 #if[Long]
237     @Test(dataProvider = "$type$UnaryOpProvider")
238     static void ADDReduceLong$vectorteststype$(IntFunction<$type$[]> fa) {
239         $type$[] a = fa.apply(SPECIES.length());
240         $type$[] r = fr.apply(SPECIES.length());
241         $type$ ra = 0;
242 
243         for (int i = 0; i < a.length; i += SPECIES.length()) {
244             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
245             r[i] = av.reduceLanesToLong(VectorOperators.ADD);
246         }
247 
248         ra = 0;
249         for (int i = 0; i < a.length; i ++) {
250             ra += r[i];
251         }
252 
253         assertReductionArraysEquals(r, ra, a,
254                 $vectorteststype$::ADDReduce, $vectorteststype$::ADDReduceAll);
255     }
256 
257     @Test(dataProvider = "$type$UnaryOpMaskProvider")
258     static void ADDReduceLong$vectorteststype$Masked(IntFunction<$type$[]> fa, IntFunction<boolean[]> fm) {
259         $type$[] a = fa.apply(SPECIES.length());
260         $type$[] r = fr.apply(SPECIES.length());
261         boolean[] mask = fm.apply(SPECIES.length());
262         VectorMask<$Wideboxtype$> vmask = VectorMask.fromArray(SPECIES, mask, 0);
263         $type$ ra = 0;
264 
265         for (int i = 0; i < a.length; i += SPECIES.length()) {
266             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
267             r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
268         }
269 
270         ra = 0;
271         for (int i = 0; i < a.length; i ++) {
272             ra += r[i];
273         }
274 
275         assertReductionArraysEqualsMasked(r, ra, a, mask,
276                 $vectorteststype$::ADDReduceMasked, $vectorteststype$::ADDReduceAllMasked);
277     }
278 #end[Long]
279 
280 #if[Int]
281     @Test(dataProvider = "$type$UnaryOpShuffleProvider")
282 #else[Int]
283     @Test(dataProvider = "$type$UnaryOpSelectFromProvider")
284 #end[Int]
285     static void SelectFrom$vectorteststype$(IntFunction<$type$[]> fa,
286                                            BiFunction<Integer,Integer,$type$[]> fs) {
287         $type$[] a = fa.apply(SPECIES.length());
288         $type$[] order = fs.apply(a.length, SPECIES.length());
289         $type$[] r = fr.apply(SPECIES.length());
290 
291         for (int i = 0; i < a.length; i += SPECIES.length()) {
292             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
293             $abstractvectortype$ bv = $abstractvectortype$.fromArray(SPECIES, order, i);
294             bv.selectFrom(av).intoArray(r, i);
295         }
296 
297         assertSelectFromArraysEquals(r, a, order, SPECIES.length());
298     }
299 
300 #if[Int]
301     @Test(dataProvider = "$type$UnaryOpShuffleMaskProvider")
302 #else[Int]
303     @Test(dataProvider = "$type$UnaryOpSelectFromMaskProvider")
304 #end[Int]
305     static void SelectFrom$vectorteststype$MaskedSmokeTest(IntFunction<$type$[]> fa,
306                                                            BiFunction<Integer,Integer,$type$[]> fs,
307                                                            IntFunction<boolean[]> fm) {
308         $type$[] a = fa.apply(SPECIES.length());
309         $type$[] order = fs.apply(a.length, SPECIES.length());
310         $type$[] r = fr.apply(SPECIES.length());
311         boolean[] mask = fm.apply(SPECIES.length());
312         VectorMask<$Wideboxtype$> vmask = VectorMask.fromArray(SPECIES, mask, 0);
313 
314         for (int i = 0; i < a.length; i += SPECIES.length()) {
315             $abstractvectortype$ av = $abstractvectortype$.fromArray(SPECIES, a, i);
316             $abstractvectortype$ bv = $abstractvectortype$.fromArray(SPECIES, order, i);
317             bv.selectFrom(av, vmask).intoArray(r, i);
318         }
319 
320         assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
321     }
322 
323     @Test(dataProvider = "shuffleProvider")
324     static void shuffleMiscellaneous$vectorteststype$SmokeTest(BiFunction<Integer,Integer,int[]> fs) {
325         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
326 
327         for (int i = 0; i < a.length; i += SPECIES.length()) {
328             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
329             int hash = shuffle.hashCode();
330             int length = shuffle.length();
331 
332             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
333             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
334             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
335             Assert.assertEquals(length, SPECIES.length());
336         }
337     }
338 
339     @Test(dataProvider = "shuffleProvider")
340     static void shuffleToString$vectorteststype$SmokeTest(BiFunction<Integer,Integer,int[]> fs) {
341         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
342 
343         for (int i = 0; i < a.length; i += SPECIES.length()) {
344             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
345             String str = shuffle.toString();
346 
347             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
348             Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
349                 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
350         }
351     }
352 
353     @Test(dataProvider = "shuffleCompareOpProvider")
354     static void shuffleEquals$vectorteststype$SmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
355         int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
356         int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
357 
358         for (int i = 0; i < a.length; i += SPECIES.length()) {
359             var av = VectorShuffle.fromArray(SPECIES, a, i);
360             var bv = VectorShuffle.fromArray(SPECIES, b, i);
361             boolean eq = av.equals(bv);
362             int to = i + SPECIES.length();
363             Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
364         }
365     }
366 
367     @Test(dataProvider = "maskCompareOpProvider")
368     static void maskEquals$vectorteststype$SmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
369         boolean[] a = fa.apply(SPECIES.length());
370         boolean[] b = fb.apply(SPECIES.length());
371 
372         for (int i = 0; i < a.length; i += SPECIES.length()) {
373             var av = SPECIES.loadMask(a, i);
374             var bv = SPECIES.loadMask(b, i);
375             boolean equals = av.equals(bv);
376             int to = i + SPECIES.length();
377             Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
378         }
379     }
380 
381     static boolean beq(boolean a, boolean b) {
382         return (a == b);
383     }
384 
385     @Test(dataProvider = "maskCompareOpProvider")
386     static void maskEq$vectorteststype$SmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
387         boolean[] a = fa.apply(SPECIES.length());
388         boolean[] b = fb.apply(SPECIES.length());
389         boolean[] r = new boolean[a.length];
390 
391         for (int i = 0; i < a.length; i += SPECIES.length()) {
392             var av = SPECIES.loadMask(a, i);
393             var bv = SPECIES.loadMask(b, i);
394             var cv = av.eq(bv);
395             cv.intoArray(r, i);
396         }
397         assertArraysEquals(r, a, b, $vectorteststype$::beq);
398     }
399 
400     @Test(dataProvider = "maskProvider")
401     static void maskHashCode$vectorteststype$SmokeTest(IntFunction<boolean[]> fa) {
402         boolean[] a = fa.apply(SPECIES.length());
403 
404         for (int i = 0; i < a.length; i += SPECIES.length()) {
405             var vmask = SPECIES.loadMask(a, i);
406             int hash = vmask.hashCode();
407 
408             boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
409             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
410             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
411         }
412     }
413 
414     static int maskTrueCount(boolean[] a, int idx) {
415         int trueCount = 0;
416         for (int i = idx; i < idx + SPECIES.length(); i++) {
417             trueCount += a[i] ? 1 : 0;
418         }
419         return trueCount;
420     }
421 
422     @Test(dataProvider = "maskProvider")
423     static void maskTrueCount$vectorteststype$SmokeTest(IntFunction<boolean[]> fa) {
424         boolean[] a = fa.apply(SPECIES.length());
425         int[] r = new int[a.length];
426 
427         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
428             for (int i = 0; i < a.length; i += SPECIES.length()) {
429                 var vmask = SPECIES.loadMask(a, i);
430                 r[i] = vmask.trueCount();
431             }
432         }
433 
434         assertMaskReductionArraysEquals(r, a, $vectorteststype$::maskTrueCount);
435     }
436 
437     static int maskLastTrue(boolean[] a, int idx) {
438         int i = idx + SPECIES.length() - 1;
439         for (; i >= idx; i--) {
440             if (a[i]) {
441                 break;
442             }
443         }
444         return i - idx;
445     }
446 
447     @Test(dataProvider = "maskProvider")
448     static void maskLastTrue$vectorteststype$SmokeTest(IntFunction<boolean[]> fa) {
449         boolean[] a = fa.apply(SPECIES.length());
450         int[] r = new int[a.length];
451 
452         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
453             for (int i = 0; i < a.length; i += SPECIES.length()) {
454                 var vmask = SPECIES.loadMask(a, i);
455                 r[i] = vmask.lastTrue();
456             }
457         }
458 
459         assertMaskReductionArraysEquals(r, a, $vectorteststype$::maskLastTrue);
460     }
461 
462     static int maskFirstTrue(boolean[] a, int idx) {
463         int i = idx;
464         for (; i < idx + SPECIES.length(); i++) {
465             if (a[i]) {
466                 break;
467             }
468         }
469         return i - idx;
470     }
471 
472     @Test(dataProvider = "maskProvider")
473     static void maskFirstTrue$vectorteststype$SmokeTest(IntFunction<boolean[]> fa) {
474         boolean[] a = fa.apply(SPECIES.length());
475         int[] r = new int[a.length];
476 
477         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
478             for (int i = 0; i < a.length; i += SPECIES.length()) {
479                 var vmask = SPECIES.loadMask(a, i);
480                 r[i] = vmask.firstTrue();
481             }
482         }
483 
484         assertMaskReductionArraysEquals(r, a, $vectorteststype$::maskFirstTrue);
485     }
486 
487 #if[!MaxBit]
488     @DataProvider
489     public static Object[][] longMaskProvider() {
490         return new Object[][]{
491                 {0xFFFFFFFFFFFFFFFFL},
492                 {0x0000000000000000L},
493                 {0x5555555555555555L},
494                 {0x0123456789abcdefL},
495         };
496     }
497 
498     @Test(dataProvider = "longMaskProvider")
499     static void maskFromToLong$vectorteststype$SmokeTest(long inputLong) {
500         var vmask = VectorMask.fromLong(SPECIES, inputLong);
501         long outputLong = vmask.toLong();
502         Assert.assertEquals(outputLong, inputLong & (((1L << (SPECIES.length() - 1)) << 1) - 1));
503     }
504 #end[!MaxBit]
505 
506     @DataProvider
507     public static Object[][] offsetProvider() {
508         return new Object[][]{
509                 {0},
510                 {-1},
511                 {+1},
512                 {+2},
513                 {-2},
514         };
515     }
516 
517     @Test(dataProvider = "offsetProvider")
518     static void indexInRange$vectorteststype$SmokeTest(int offset) {
519         int limit = SPECIES.length() * BUFFER_REPS;
520         for (int i = 0; i < limit; i += SPECIES.length()) {
521             var actualMask = SPECIES.indexInRange(i + offset, limit);
522             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
523             assert(actualMask.equals(expectedMask));
524             for (int j = 0; j < SPECIES.length(); j++)  {
525                 int index = i + j + offset;
526                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
527             }
528         }
529     }
530 
531     @DataProvider
532     public static Object[][] lengthProvider() {
533         return new Object[][]{
534                 {0},
535                 {1},
536                 {32},
537                 {37},
538                 {1024},
539                 {1024+1},
540                 {1024+5},
541         };
542     }
543 
544     @Test(dataProvider = "lengthProvider")
545     static void loopBound$vectorteststype$SmokeTest(int length) {
546         int actualLoopBound = SPECIES.loopBound(length);
547         int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
548         Assert.assertEquals(actualLoopBound, expectedLoopBound);
549     }
550 
551     @Test
552     static void ElementSize$vectorteststype$SmokeTest() {
553         $abstractvectortype$ av = $abstractvectortype$.zero(SPECIES);
554         int elsize = av.elementSize();
555         Assert.assertEquals(elsize, $Wideboxtype$.SIZE);
556     }
557 
558     @Test
559     static void VectorShape$vectorteststype$SmokeTest() {
560         $abstractvectortype$ av = $abstractvectortype$.zero(SPECIES);
561         VectorShape vsh = av.shape();
562         assert(vsh.equals(VectorShape.$Shape$));
563     }
564 
565     @Test
566     static void ShapeWithLanes$vectorteststype$SmokeTest() {
567         $abstractvectortype$ av = $abstractvectortype$.zero(SPECIES);
568         VectorShape vsh = av.shape();
569         VectorSpecies species = vsh.withLanes($type$.class);
570         assert(species.equals(SPECIES));
571     }
572 
573     @Test
574     static void ElementType$vectorteststype$SmokeTest() {
575         $abstractvectortype$ av = $abstractvectortype$.zero(SPECIES);
576         assert(av.species().elementType() == $type$.class);
577     }
578 
579     @Test
580     static void SpeciesElementSize$vectorteststype$SmokeTest() {
581         $abstractvectortype$ av = $abstractvectortype$.zero(SPECIES);
582         assert(av.species().elementSize() == $Wideboxtype$.SIZE);
583     }
584 
585     @Test
586     static void VectorType$vectorteststype$SmokeTest() {
587         $abstractvectortype$ av = $abstractvectortype$.zero(SPECIES);
588         assert(av.species().vectorType() == av.getClass());
589     }
590 
591     @Test
592     static void WithLanes$vectorteststype$SmokeTest() {
593         $abstractvectortype$ av = $abstractvectortype$.zero(SPECIES);
594         VectorSpecies species = av.species().withLanes($type$.class);
595         assert(species.equals(SPECIES));
596     }
597 
598     @Test
599     static void WithShape$vectorteststype$SmokeTest() {
600         $abstractvectortype$ av = $abstractvectortype$.zero(SPECIES);
601         VectorShape vsh = av.shape();
602         VectorSpecies species = av.species().withShape(vsh);
603         assert(species.equals(SPECIES));
604     }