xref: /aosp_15_r20/art/test/011-array-copy2/src/Main.java (revision 795d594fd825385562da6b089ea9b2033f3abf5a) 
1 /*
2  * Copyright (C) 2024 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 class Main {
18 
19     private static class ByteArrayTests {
init(byte[] arr)20         public static byte[] init(byte[] arr) {
21             for (byte i = 0; i < arr.length; i++) {
22                 arr[i] = (byte) i;
23             }
24             return arr;
25         }
26 
assertEquals(int expected, int actual)27         public static void assertEquals(int expected, int actual) {
28             if (expected != actual) {
29                 throw new Error("Expected " + expected + ", got " + actual);
30             }
31         }
32 
createArrayOfZeroes(int size)33         public static byte[] createArrayOfZeroes(int size) {
34             byte[] arr = new byte[size];
35             return arr;
36         }
37 
createIncrementedArray(int size)38         public static byte[] createIncrementedArray(int size) {
39             byte[] arr = new byte[size];
40             init(arr);
41             return arr;
42         }
43 
checkIncrementedArray(byte[] dst)44         public static void checkIncrementedArray(byte[] dst) {
45             for (byte i = 0; i < dst.length; i++) {
46                 assertEquals(i, dst[i]);
47             }
48         }
49 
$noinline$test1(byte[] src, byte[] dst)50         public static void $noinline$test1(byte[] src, byte[] dst) {
51             System.arraycopy(src, 0, dst, 0, 15);
52         }
53 
$noinline$test2(byte[] src, byte[] dst)54         public static void $noinline$test2(byte[] src, byte[] dst) {
55             System.arraycopy(src, 0, dst, 0, 127);
56         }
57 
$noinline$test3()58         public static byte[] $noinline$test3() {
59             byte size = 15;
60             byte[] src = new byte[size];
61             src = init(src);
62             byte[] dst = new byte[size];
63 
64             System.arraycopy(src, 0, dst, 0, size);
65             return dst;
66         }
67 
$noinline$test4()68         public static byte[] $noinline$test4() {
69             int size = 127;
70             byte[] src = new byte[size];
71             src = init(src);
72             byte[] dst = new byte[size];
73 
74             System.arraycopy(src, 0, dst, 0, size);
75             return dst;
76         }
77 
$noinline$test5()78         public static byte[] $noinline$test5() {
79             byte[] src = new byte[80];
80             src = init(src);
81             byte[] dst = new byte[80];
82 
83             System.arraycopy(src, 0, dst, 0, 80);
84             return dst;
85         }
86 
$noinline$test6()87         public static byte[] $noinline$test6() {
88             byte[] src = new byte[127];
89             src = init(src);
90             byte[] dst = new byte[127];
91 
92             System.arraycopy(src, 0, dst, 100, 27);
93             return dst;
94         }
check6(byte[] dst)95         public static void check6(byte[] dst) {
96             for (byte i = 0; i < 100; i++) {
97                 assertEquals(0, dst[i]);
98             }
99             for (byte i = 100; i < 127; i++) {
100                 assertEquals(i - 100, dst[i]);
101             }
102         }
103 
$noinline$test7()104         public static byte[] $noinline$test7() {
105             byte[] src = new byte[127];
106             src = init(src);
107 
108             System.arraycopy(src, 0, src, 100, 27);
109             return src;
110         }
check7(byte[] dst)111         public static void check7(byte[] dst) {
112             for (byte i = 0; i < 100; i++) {
113                 assertEquals(i, dst[i]);
114             }
115             for (byte i = 100; i < 127; i++) {
116                 assertEquals(i - 100, dst[i]);
117             }
118         }
119 
$noinline$test8()120         public static byte[] $noinline$test8() {
121             byte[] src = new byte[127];
122             src = init(src);
123 
124             System.arraycopy(src, 100, src, 0, 27);
125             return src;
126         }
check8(byte[] dst)127         public static void check8(byte[] dst) {
128             for (byte i = 0; i < 27; i++) {
129                 assertEquals(100 + i, dst[i]);
130             }
131             for (byte i = 27; i < 127; i++) {
132                 assertEquals(i, dst[i]);
133             }
134         }
135 
$noinline$test9(byte[] src, byte[] dst, byte i)136         public static void $noinline$test9(byte[] src, byte[] dst, byte i) {
137             System.arraycopy(src, 0, dst, 0, i);
138         }
139 
runTests()140         public static void runTests() {
141             System.out.print("[ByteArrayTests]: ");
142 
143             byte[] src15 = createIncrementedArray(15);
144             byte[] dst15 = createArrayOfZeroes(15);
145             $noinline$test1(src15, dst15);
146             checkIncrementedArray(dst15);
147 
148             byte[] src150 = createIncrementedArray(127);
149             byte[] dst150 = createArrayOfZeroes(127);
150             $noinline$test2(src150, dst150);
151             checkIncrementedArray(dst150);
152 
153             checkIncrementedArray($noinline$test3());
154             checkIncrementedArray($noinline$test4());
155             checkIncrementedArray($noinline$test5());
156 
157             check6($noinline$test6());
158             check7($noinline$test7());
159             check8($noinline$test8());
160 
161             for (byte i = 1; i < 127; i++) {
162                 byte[] src = createIncrementedArray(i);
163                 byte[] dst = createArrayOfZeroes(i);
164                 $noinline$test9(src, dst, i);
165                 checkIncrementedArray(dst);
166             }
167             System.out.println("passed");
168         }
169     }
170 
171     private static class CharArrayTests {
172 
init(char[] arr)173         public static char[] init(char[] arr) {
174             for (int i = 0; i < arr.length; i++) {
175                 arr[i] = (char) i;
176             }
177             return arr;
178         }
179 
assertEquals(int expected, int actual)180         public static void assertEquals(int expected, int actual) {
181             if (expected != actual) {
182                 throw new Error("Expected " + expected + ", got " + actual);
183             }
184         }
185 
createArrayOfZeroes(int size)186         public static char[] createArrayOfZeroes(int size) {
187             char[] arr = new char[size];
188             return arr;
189         }
190 
createIncrementedArray(int size)191         public static char[] createIncrementedArray(int size) {
192             char[] arr = new char[size];
193             init(arr);
194             return arr;
195         }
196 
checkIncrementedArray(char[] dst)197         public static void checkIncrementedArray(char[] dst) {
198             for (int i = 0; i < dst.length; i++) {
199                 assertEquals(i, dst[i]);
200             }
201         }
202 
$noinline$test1(char[] src, char[] dst)203         public static void $noinline$test1(char[] src, char[] dst) {
204             System.arraycopy(src, 0, dst, 0, 15);
205         }
206 
$noinline$test2(char[] src, char[] dst)207         public static void $noinline$test2(char[] src, char[] dst) {
208             System.arraycopy(src, 0, dst, 0, 150);
209         }
210 
$noinline$test3()211         public static char[] $noinline$test3() {
212             int size = 15;
213             char[] src = new char[size];
214             src = init(src);
215             char[] dst = new char[size];
216 
217             System.arraycopy(src, 0, dst, 0, size);
218             return dst;
219         }
220 
$noinline$test4()221         public static char[] $noinline$test4() {
222             int size = 150;
223             char[] src = new char[size];
224             src = init(src);
225             char[] dst = new char[size];
226 
227             System.arraycopy(src, 0, dst, 0, size);
228             return dst;
229         }
230 
$noinline$test5()231         public static char[] $noinline$test5() {
232             char[] src = new char[80];
233             src = init(src);
234             char[] dst = new char[80];
235 
236             System.arraycopy(src, 0, dst, 0, 80);
237             return dst;
238         }
239 
$noinline$test6()240         public static char[] $noinline$test6() {
241             char[] src = new char[150];
242             src = init(src);
243             char[] dst = new char[150];
244 
245             System.arraycopy(src, 0, dst, 100, 50);
246             return dst;
247         }
check6(char[] dst)248         public static void check6(char[] dst) {
249             for (int i = 0; i < 100; i++) {
250                 assertEquals(0, dst[i]);
251             }
252             for (int i = 100; i < 150; i++) {
253                 assertEquals(i-100, dst[i]);
254             }
255         }
256 
$noinline$test7()257         public static char[] $noinline$test7() {
258             char[] src = new char[150];
259             src = init(src);
260 
261             System.arraycopy(src, 0, src, 100, 50);
262             return src;
263         }
check7(char[] dst)264         public static void check7(char[] dst) {
265             for (int i = 0; i < 100; i++) {
266                 assertEquals(i, dst[i]);
267             }
268             for (int i = 100; i < 150; i++) {
269                 assertEquals(i - 100, dst[i]);
270             }
271         }
272 
$noinline$test8()273         public static char[] $noinline$test8() {
274             char[] src = new char[150];
275             src = init(src);
276 
277             System.arraycopy(src, 100, src, 0, 50);
278             return src;
279         }
check8(char[] dst)280         public static void check8(char[] dst) {
281             for (int i = 0; i < 50; i++) {
282                 assertEquals(100 + i, dst[i]);
283             }
284             for (int i = 50; i < 150; i++) {
285                 assertEquals(i, dst[i]);
286             }
287         }
288 
$noinline$test9(char[] src, char[] dst, int i)289         public static void $noinline$test9(char[] src, char[] dst, int i) {
290             System.arraycopy(src, 0, dst, 0, i);
291         }
292 
runTests()293         public static void runTests() {
294             System.out.print("[CharArrayTests]: ");
295 
296             char[] src15 = createIncrementedArray(15);
297             char[] dst15 = createArrayOfZeroes(15);
298             $noinline$test1(src15, dst15);
299             checkIncrementedArray(dst15);
300 
301             char[] src150 = createIncrementedArray(150);
302             char[] dst150 = createArrayOfZeroes(150);
303             $noinline$test2(src150, dst150);
304             checkIncrementedArray(dst150);
305 
306             checkIncrementedArray($noinline$test3());
307             checkIncrementedArray($noinline$test4());
308             checkIncrementedArray($noinline$test5());
309 
310             check6($noinline$test6());
311             check7($noinline$test7());
312             check8($noinline$test8());
313 
314             for (int i = 1; i < 256; i++) {
315                 char[] src = createIncrementedArray(i);
316                 char[] dst = createArrayOfZeroes(i);
317                 $noinline$test9(src, dst, i);
318                 checkIncrementedArray(dst);
319             }
320 
321             System.out.println("passed");
322         }
323     }
324 
325     private static class IntArrayTests {
init(int[] arr)326         public static int[] init(int[] arr) {
327             for (int i = 0; i < arr.length; i++) {
328                 arr[i] = (int) i;
329             }
330             return arr;
331         }
332 
assertEquals(int expected, int actual)333         public static void assertEquals(int expected, int actual) {
334             if (expected != actual) {
335                 throw new Error("Expected " + expected + ", got " + actual);
336             }
337         }
338 
createArrayOfZeroes(int size)339         public static int[] createArrayOfZeroes(int size) {
340             int[] arr = new int[size];
341             return arr;
342         }
343 
createIncrementedArray(int size)344         public static int[] createIncrementedArray(int size) {
345             int[] arr = new int[size];
346             init(arr);
347             return arr;
348         }
349 
checkIncrementedArray(int[] dst)350         public static void checkIncrementedArray(int[] dst) {
351             for (int i = 0; i < dst.length; i++) {
352                 assertEquals(i, dst[i]);
353             }
354         }
355 
$noinline$test1(int[] src, int[] dst)356         public static void $noinline$test1(int[] src, int[] dst) {
357             System.arraycopy(src, 0, dst, 0, 15);
358         }
359 
$noinline$test2(int[] src, int[] dst)360         public static void $noinline$test2(int[] src, int[] dst) {
361             System.arraycopy(src, 0, dst, 0, 150);
362         }
363 
$noinline$test3()364         public static int[] $noinline$test3() {
365             int size = 15;
366             int[] src = new int[size];
367             src = init(src);
368             int[] dst = new int[size];
369 
370             System.arraycopy(src, 0, dst, 0, size);
371             return dst;
372         }
373 
$noinline$test4()374         public static int[] $noinline$test4() {
375             int size = 150;
376             int[] src = new int[size];
377             src = init(src);
378             int[] dst = new int[size];
379 
380             System.arraycopy(src, 0, dst, 0, size);
381             return dst;
382         }
383 
$noinline$test5()384         public static int[] $noinline$test5() {
385             int[] src = new int[80];
386             src = init(src);
387             int[] dst = new int[80];
388 
389             System.arraycopy(src, 0, dst, 0, 80);
390             return dst;
391         }
392 
$noinline$test6()393         public static int[] $noinline$test6() {
394             int[] src = new int[150];
395             src = init(src);
396             int[] dst = new int[150];
397 
398             System.arraycopy(src, 0, dst, 100, 50);
399             return dst;
400         }
check6(int[] dst)401         public static void check6(int[] dst) {
402             for (int i = 0; i < 100; i++) {
403                 assertEquals(0, dst[i]);
404             }
405             for (int i = 100; i < 150; i++) {
406                 assertEquals(i-100, dst[i]);
407             }
408         }
409 
$noinline$test7()410         public static int[] $noinline$test7() {
411             int[] src = new int[150];
412             src = init(src);
413 
414             System.arraycopy(src, 0, src, 100, 50);
415             return src;
416         }
check7(int[] dst)417         public static void check7(int[] dst) {
418             for (int i = 0; i < 100; i++) {
419                 assertEquals(i, dst[i]);
420             }
421             for (int i = 100; i < 150; i++) {
422                 assertEquals(i - 100, dst[i]);
423             }
424         }
425 
$noinline$test8()426         public static int[] $noinline$test8() {
427             int[] src = new int[150];
428             src = init(src);
429 
430             System.arraycopy(src, 100, src, 0, 50);
431             return src;
432         }
check8(int[] dst)433         public static void check8(int[] dst) {
434             for (int i = 0; i < 50; i++) {
435                 assertEquals(100 + i, dst[i]);
436             }
437             for (int i = 50; i < 150; i++) {
438                 assertEquals(i, dst[i]);
439             }
440         }
441 
$noinline$test9(int[] src, int[] dst, int i)442         public static void $noinline$test9(int[] src, int[] dst, int i) {
443             System.arraycopy(src, 0, dst, 0, i);
444         }
445 
runTests()446         public static void runTests() {
447             System.out.print("[IntArrayTests]: ");
448 
449             int[] src15 = createIncrementedArray(15);
450             int[] dst15 = createArrayOfZeroes(15);
451             $noinline$test1(src15, dst15);
452             checkIncrementedArray(dst15);
453 
454             int[] src150 = createIncrementedArray(150);
455             int[] dst150 = createArrayOfZeroes(150);
456             $noinline$test2(src150, dst150);
457             checkIncrementedArray(dst150);
458 
459             checkIncrementedArray($noinline$test3());
460             checkIncrementedArray($noinline$test4());
461             checkIncrementedArray($noinline$test5());
462 
463             check6($noinline$test6());
464             check7($noinline$test7());
465             check8($noinline$test8());
466 
467             for (int i = 1; i < 256; i++) {
468                 int[] src = createIncrementedArray(i);
469                 int[] dst = createArrayOfZeroes(i);
470                 $noinline$test9(src, dst, i);
471                 checkIncrementedArray(dst);
472             }
473 
474             System.out.println("passed");
475         }
476     }
477 
main(String[] args)478     public static void main(String[] args) {
479         ByteArrayTests.runTests();
480         CharArrayTests.runTests();
481         IntArrayTests.runTests();
482     }
483 }
484