xref: /aosp_15_r20/art/test/021-string2/src/Main.java (revision 795d594fd825385562da6b089ea9b2033f3abf5a) 
1 /*
2  * Copyright (C) 2007 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 import junit.framework.Assert;
18 import java.util.Locale;
19 
20 /**
21  * more string tests
22  */
23 public class Main {
main(String args[])24     public static void main(String args[]) {
25         String test = "0123456789";
26         String test1 = new String("0123456789");    // different object
27         String test2 = new String("0123456780");    // different value
28         String offset = new String("xxx0123456789yyy");
29         String sub = offset.substring(3, 13);
30         Object blah = new Object();
31 
32         Assert.assertTrue(test.equals(test));
33         Assert.assertTrue(test.equals(test1));
34         Assert.assertFalse(test.equals(test2));
35 
36         Assert.assertEquals(test.compareTo(test1), 0);
37         Assert.assertTrue(test1.compareTo(test2) > 0);
38         Assert.assertTrue(test2.compareTo(test1) < 0);
39 
40         Assert.assertEquals("".compareTo(""), 0);
41         Assert.assertTrue(test.compareTo("") > 0);
42         Assert.assertTrue("".compareTo(test) < 0);
43 
44         /* compare string with a nonzero offset, in left/right side */
45         Assert.assertEquals(test.compareTo(sub), 0);
46         Assert.assertEquals(sub.compareTo(test), 0);
47         Assert.assertTrue(test.equals(sub));
48         Assert.assertTrue(sub.equals(test));
49         /* same base, one is a substring */
50         Assert.assertFalse(offset.equals(sub));
51         Assert.assertFalse(sub.equals(offset));
52         /* wrong class */
53         Assert.assertFalse(test.equals(blah));
54 
55         /* null ptr - throw */
56         try {
57             test.compareTo(null);
58             Assert.fail("didn't get expected npe");
59         } catch (NullPointerException npe) {
60             System.out.println("Got expected npe");
61         }
62         /* null ptr - ok */
63         Assert.assertFalse(test.equals(null));
64 
65         test = test.substring(1);
66         Assert.assertTrue(test.equals("123456789"));
67         Assert.assertFalse(test.equals(test1));
68 
69         test = test.substring(1);
70         Assert.assertTrue(test.equals("23456789"));
71 
72         test = test.substring(1);
73         Assert.assertTrue(test.equals("3456789"));
74 
75         test = test.substring(1);
76         Assert.assertTrue(test.equals("456789"));
77 
78         test = test.substring(3,5);
79         Assert.assertTrue(test.equals("78"));
80 
81         test = "this/is/a/path";
82         String[] strings = test.split("/");
83         Assert.assertEquals(4, strings.length);
84 
85         Assert.assertEquals("this is a path", test.replaceAll("/", " "));
86         Assert.assertEquals("this is a path", test.replace("/", " "));
87 
88         String result = new String(new char[] { 'O', 'K' });
89         System.out.println(result);
90 
91         testCompareToAndEquals();
92         testIndexOf();
93 
94         String s0_0 = "\u0000";
95         String s0_1 = new String(s0_0);
96         String s0_2 = new String(new char[] { '\u0000' });
97         String s0_3 = s0_0 + "";
98         System.out.println(
99             " " + $noinline$equals(s0_0, s0_0) +
100             " " + $noinline$equals(s0_0, s0_1) +
101             " " + $noinline$equals(s0_0, s0_2) +
102             " " + $noinline$equals(s0_0, s0_3));
103         System.out.println(
104             " " + $noinline$equals(s0_1, s0_0) +
105             " " + $noinline$equals(s0_1, s0_1) +
106             " " + $noinline$equals(s0_1, s0_2) +
107             " " + $noinline$equals(s0_1, s0_3));
108         System.out.println(
109             " " + $noinline$equals(s0_2, s0_0) +
110             " " + $noinline$equals(s0_2, s0_1) +
111             " " + $noinline$equals(s0_2, s0_2) +
112             " " + $noinline$equals(s0_2, s0_3));
113         System.out.println(
114             " " + $noinline$equals(s0_3, s0_0) +
115             " " + $noinline$equals(s0_3, s0_1) +
116             " " + $noinline$equals(s0_3, s0_2) +
117             " " + $noinline$equals(s0_3, s0_3));
118 
119         testEqualsConstString();
120         testConstStringEquals();
121         testStringConcat();
122         testEmptyWithHighByte();
123 
124         // Regression tests for String.setCharAt() breaking string compression invariants.
125         Locale en_US = new Locale("en", "US");
126         Assert.assertEquals("I", /* Small latin dotless i */ "\u0131".toUpperCase());
127         Assert.assertEquals("abc", "a\u0131c".replace('\u0131', 'b'));
128         Assert.assertEquals("a\u0131c", "abc".replace('b', '\u0131'));
129 
130         // Regression test for scratch register exhaustion in String.equals() intrinsic on arm64.
131         Assert.assertFalse(result.equals("Very long constant string, so that the known constant count field cannot be embedded in a CMP immediate instruction on arm64. Since it can hold 12-bit values, optionally shifted left by 12, let's go somewhere over 2^12, i.e. 4096. That should trigger the bug with or without string compression. 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"));
132     }
133 
testCompareToAndEquals()134     public static void testCompareToAndEquals() {
135         String[] strings = {
136                 // Special: empty string.
137                 "",
138                 // Category 0, ASCII strings:
139                 //     "0123456789abcdef".substring(0, index + 1)
140                 "0",
141                 "01",
142                 "012",
143                 "0123",
144                 "01234",
145                 "012345",
146                 "0123456",
147                 "01234567",
148                 "012345678",
149                 "0123456789",
150                 "0123456789a",
151                 "0123456789ab",
152                 "0123456789abc",
153                 "0123456789abcd",
154                 "0123456789abcde",
155                 "0123456789abcdef",
156                 // Category 1, ASCII strings:
157                 //     "0123456789abcdef".substring(0, index) + "x"
158                 "x",
159                 "0x",
160                 "01x",
161                 "012x",
162                 "0123x",
163                 "01234x",
164                 "012345x",
165                 "0123456x",
166                 "01234567x",
167                 "012345678x",
168                 "0123456789x",
169                 "0123456789ax",
170                 "0123456789abx",
171                 "0123456789abcx",
172                 "0123456789abcdx",
173                 "0123456789abcdex",
174                 // Category 2, ASCII strings,
175                 //     "0123456789abcdef".substring(0, index) + "x" +
176                 //     "0123456789abcdef".substring(index + 1)
177                 "x123456789abcdef",
178                 "0x23456789abcdef",
179                 "01x3456789abcdef",
180                 "012x456789abcdef",
181                 "0123x56789abcdef",
182                 "01234x6789abcdef",
183                 "012345x789abcdef",
184                 "0123456x89abcdef",
185                 "01234567x9abcdef",
186                 "012345678xabcdef",
187                 "0123456789xbcdef",
188                 "0123456789axcdef",
189                 "0123456789abxdef",
190                 "0123456789abcxef",
191                 "0123456789abcdxf",
192                 "0123456789abcdex",
193                 // Category 3, ASCII strings:
194                 //     "z" + "0123456789abcdef".substring(1, index + 1)
195                 "z",
196                 "z1",
197                 "z12",
198                 "z123",
199                 "z1234",
200                 "z12345",
201                 "z123456",
202                 "z1234567",
203                 "z12345678",
204                 "z123456789",
205                 "z123456789a",
206                 "z123456789ab",
207                 "z123456789abc",
208                 "z123456789abcd",
209                 "z123456789abcde",
210                 "z123456789abcdef",
211                 // Category 4, non-ASCII strings:
212                 //     "0123456789abcdef".substring(0, index) + "\u0440"
213                 "\u0440",
214                 "0\u0440",
215                 "01\u0440",
216                 "012\u0440",
217                 "0123\u0440",
218                 "01234\u0440",
219                 "012345\u0440",
220                 "0123456\u0440",
221                 "01234567\u0440",
222                 "012345678\u0440",
223                 "0123456789\u0440",
224                 "0123456789a\u0440",
225                 "0123456789ab\u0440",
226                 "0123456789abc\u0440",
227                 "0123456789abcd\u0440",
228                 "0123456789abcde\u0440",
229                 // Category 5, non-ASCII strings:
230                 //     "0123456789abcdef".substring(0, index) + "\u0440" +
231                 //     "0123456789abcdef".substring(index + 1)
232                 "\u0440123456789abcdef",
233                 "0\u044023456789abcdef",
234                 "01\u04403456789abcdef",
235                 "012\u0440456789abcdef",
236                 "0123\u044056789abcdef",
237                 "01234\u04406789abcdef",
238                 "012345\u0440789abcdef",
239                 "0123456\u044089abcdef",
240                 "01234567\u04409abcdef",
241                 "012345678\u0440abcdef",
242                 "0123456789\u0440bcdef",
243                 "0123456789a\u0440cdef",
244                 "0123456789ab\u0440def",
245                 "0123456789abc\u0440ef",
246                 "0123456789abcd\u0440f",
247                 "0123456789abcde\u0440",
248                 // Category 6, ASCII strings:
249                 //     "\u0443" + "0123456789abcdef".substring(1, index + 1)
250                 "\u0443",
251                 "\u04431",
252                 "\u044312",
253                 "\u0443123",
254                 "\u04431234",
255                 "\u044312345",
256                 "\u0443123456",
257                 "\u04431234567",
258                 "\u044312345678",
259                 "\u0443123456789",
260                 "\u0443123456789a",
261                 "\u0443123456789ab",
262                 "\u0443123456789abc",
263                 "\u0443123456789abcd",
264                 "\u0443123456789abcde",
265                 "\u0443123456789abcdef",
266                 // Category 7, non-ASCII strings:
267                 //     "0123456789abcdef".substring(0, index) + "\u0482"
268                 "\u0482",
269                 "0\u0482",
270                 "01\u0482",
271                 "012\u0482",
272                 "0123\u0482",
273                 "01234\u0482",
274                 "012345\u0482",
275                 "0123456\u0482",
276                 "01234567\u0482",
277                 "012345678\u0482",
278                 "0123456789\u0482",
279                 "0123456789a\u0482",
280                 "0123456789ab\u0482",
281                 "0123456789abc\u0482",
282                 "0123456789abcd\u0482",
283                 "0123456789abcde\u0482",
284                 // Category 8, non-ASCII strings:
285                 //     "0123456789abcdef".substring(0, index) + "\u0482" +
286                 //     "0123456789abcdef".substring(index + 1)
287                 "\u0482123456789abcdef",
288                 "0\u048223456789abcdef",
289                 "01\u04823456789abcdef",
290                 "012\u0482456789abcdef",
291                 "0123\u048256789abcdef",
292                 "01234\u04826789abcdef",
293                 "012345\u0482789abcdef",
294                 "0123456\u048289abcdef",
295                 "01234567\u04829abcdef",
296                 "012345678\u0482abcdef",
297                 "0123456789\u0482bcdef",
298                 "0123456789a\u0482cdef",
299                 "0123456789ab\u0482def",
300                 "0123456789abc\u0482ef",
301                 "0123456789abcd\u0482f",
302                 "0123456789abcde\u0482",
303                 // Category 9, ASCII strings:
304                 //     "\u0489" + "0123456789abcdef".substring(1, index + 1)
305                 "\u0489",
306                 "\u04891",
307                 "\u048912",
308                 "\u0489123",
309                 "\u04891234",
310                 "\u048912345",
311                 "\u0489123456",
312                 "\u04891234567",
313                 "\u048912345678",
314                 "\u0489123456789",
315                 "\u0489123456789a",
316                 "\u0489123456789ab",
317                 "\u0489123456789abc",
318                 "\u0489123456789abcd",
319                 "\u0489123456789abcde",
320                 "\u0489123456789abcdef",
321         };
322         int length = strings.length;
323         Assert.assertEquals(1 + 16 * 10, length);
324         for (int i = 0; i != length; ++i) {
325             String lhs = strings[i];
326             for (int j = 0; j != length; ++j) {
327                 String rhs = strings[j];
328                 int result = $noinline$compareTo(lhs, rhs);
329                 final int expected;
330                 if (i == 0 || j == 0 || i == j) {
331                     // One of the strings is empty or the strings are the same.
332                     expected = lhs.length() - rhs.length();
333                 } else {
334                     int i_category = (i - 1) / 16;
335                     int i_index = (i - 1) % 16;
336                     int j_category = (j - 1) / 16;
337                     int j_index = (j - 1) % 16;
338                     int min_ij_index = (i_index < j_index) ? i_index : j_index;
339                     if (i_category == j_category) {
340                         switch (i_category) {
341                             case 0: case 3: case 6: case 9:
342                                 // Differs in length.
343                                 expected = lhs.length() - rhs.length();
344                                 break;
345                             case 1: case 2: case 4: case 5: case 7: case 8:
346                                 // Differs in charAt(min_ij_index).
347                                 expected = lhs.charAt(min_ij_index) - rhs.charAt(min_ij_index);
348                                 break;
349                             default: throw new Error("Unexpected category.");
350                       }
351                     } else if (i_category == 3 || i_category == 6 || i_category == 9 ||
352                                j_category == 3 || j_category == 6 || j_category == 9) {
353                         // In these categories, charAt(0) differs from other categories' strings.
354                         expected = lhs.charAt(0) - rhs.charAt(0);
355                     } else if (// Category 0 string is a prefix to any longer string in
356                                // remaining categories.
357                                (i_category == 0 && i_index < j_index) ||
358                                (j_category == 0 && j_index < i_index) ||
359                                // Category 2 string is a prefix to category 3 string at the same
360                                // index. Similar for categories 4 and 5 and also 7 and 8.
361                                // This includes matching last strings of these pairs of categories.
362                                (i_index == j_index &&
363                                    ((i_category == 1 && j_category == 2) ||
364                                     (i_category == 2 && j_category == 1) ||
365                                     (i_category == 4 && j_category == 5) ||
366                                     (i_category == 5 && j_category == 4) ||
367                                     (i_category == 7 && j_category == 8) ||
368                                     (i_category == 8 && j_category == 7)))) {
369                         // Differs in length.
370                         expected = lhs.length() - rhs.length();
371                     } else {
372                         // The remaining cases differ in charAt(min_ij_index), the characters
373                         // before that are "0123456789abcdef".substring(0, min_ij_index).
374                         for (int k = 0; k < min_ij_index; ++k) {
375                           Assert.assertEquals("0123456789abcdef".charAt(k), lhs.charAt(k));
376                           Assert.assertEquals("0123456789abcdef".charAt(k), rhs.charAt(k));
377                         }
378                         expected = lhs.charAt(min_ij_index) - rhs.charAt(min_ij_index);
379                         Assert.assertFalse(expected == 0);
380                     }
381                 }
382                 if (expected != result) {
383                   throw new Error(
384                       "Mismatch at i=" + i + ", j=" + j + ", expected=" + expected +
385                       ", result=" + result);
386                 }
387                 boolean equalsExpected =
388                     (i == j) ||
389                     // Last string in categories 1 and 2.
390                     (i == 32 && j == 48) || (i == 48 && j == 32) ||
391                     // Last string in categories 4 and 5.
392                     (i == 80 && j == 96) || (i == 96 && j == 80) ||
393                     // Last string in categories 7 and 8.
394                     (i == 128 && j == 144) || (i == 144 && j == 128);
395                 Assert.assertEquals(equalsExpected, $noinline$equals(lhs, rhs));
396             }
397         }
398 
399         try {
400             $noinline$compareTo("", null);
401             Assert.fail();
402         } catch (NullPointerException expected) {
403         }
404         try {
405             $noinline$compareTo(null, "");
406             Assert.fail();
407         } catch (NullPointerException expected) {
408         }
409 
410         Assert.assertFalse($noinline$equals("", null));
411         try {
412             $noinline$equals(null, "");
413             Assert.fail();
414         } catch (NullPointerException expected) {
415         }
416     }
417 
testIndexOf()418     public static void testIndexOf() {
419         String[] prefixes = {
420                 "",
421                 "0",
422                 "01",
423                 "012",
424                 "0123",
425                 "01234",
426                 "012345",
427                 "0123456",
428                 "01234567",
429                 "012345678",
430                 "0123456789",
431                 "0123456789a",
432                 "0123456789ab",
433                 "0123456789abc",
434                 "0123456789abcd",
435                 "0123456789abcdef",
436         };
437         String[] cores = {
438                 "",
439                 "x",
440                 "xx",
441                 "xxx",
442                 "xxxx",
443                 "xxxxx",
444                 "xxxxxx",
445                 "xxxxxxx",
446                 "xxxxxxxx",
447                 "xzx",
448                 "xxzx",
449                 "xxxzx",
450                 "xxxxzx",
451                 "xxxxxzx",
452                 "xxxxxxzx",
453                 "xxxxxxxzx",
454                 "xxxxxxxxzx",
455                 "\u0440",
456                 "\u0440\u0440",
457                 "\u0440\u0440\u0440",
458                 "\u0440\u0440\u0440\u0440",
459                 "\u0440\u0440\u0440\u0440\u0440",
460                 "\u0440\u0440\u0440\u0440\u0440\u0440",
461                 "\u0440\u0440\u0440\u0440\u0440\u0440\u0440",
462                 "\u0440\u0440\u0440\u0440\u0440\u0440\u0440\u0440",
463                 "\u0440z\u0440",
464                 "\u0440\u0440z\u0440",
465                 "\u0440\u0440\u0440z\u0440",
466                 "\u0440\u0440\u0440\u0440z\u0440",
467                 "\u0440\u0440\u0440\u0440\u0440z\u0440",
468                 "\u0440\u0440\u0440\u0440\u0440\u0440z\u0440",
469                 "\u0440\u0440\u0440\u0440\u0440\u0440\u0440z\u0440",
470                 "\u0440\u0440\u0440\u0440\u0440\u0440\u0440\u0440z\u0440",
471                 "\u0000",
472                 "\u0000\u0000",
473                 "\u0000\u0000\u0000",
474                 "\u0000\u0000\u0000\u0000",
475                 "\u0000\u0000\u0000\u0000\u0000",
476                 "\u0000\u0000\u0000\u0000\u0000\u0000",
477                 "\u0000\u0000\u0000\u0000\u0000\u0000\u0000",
478                 "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000",
479                 "\u0000z\u0000",
480                 "\u0000\u0000z\u0000",
481                 "\u0000\u0000\u0000z\u0000",
482                 "\u0000\u0000\u0000\u0000z\u0000",
483                 "\u0000\u0000\u0000\u0000\u0000z\u0000",
484                 "\u0000\u0000\u0000\u0000\u0000\u0000z\u0000",
485                 "\u0000\u0000\u0000\u0000\u0000\u0000\u0000z\u0000",
486                 "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000z\u0000",
487         };
488         String[] suffixes = {
489                 "",
490                 "y",
491                 "yy",
492                 "yyy",
493                 "yyyy",
494                 "yyyyy",
495                 "yyyyyy",
496                 "yyyyyyy",
497                 "yyyyyyyy",
498                 "\u0441",
499                 "y\u0441",
500                 "yy\u0441",
501                 "yyy\u0441",
502                 "yyyy\u0441",
503                 "yyyyy\u0441",
504                 "yyyyyy\u0441",
505                 "yyyyyyy\u0441",
506                 "yyyyyyyy\u0441",
507         };
508         for (String p : prefixes) {
509             for (String c : cores) {
510                 for (String s : suffixes) {
511                     String full = p + c + s;
512                     int expX = (c.isEmpty() || c.charAt(0) != 'x') ? -1 : p.length();
513                     int exp0440 = (c.isEmpty() || c.charAt(0) != '\u0440') ? -1 : p.length();
514                     int exp0000 = (c.isEmpty() || c.charAt(0) != '\u0000') ? -1 : p.length();
515                     Assert.assertEquals(expX, $noinline$indexOf(full, 'x'));
516                     Assert.assertEquals(exp0440, $noinline$indexOf(full, '\u0440'));
517                     Assert.assertEquals(exp0000, $noinline$indexOf(full, '\u0000'));
518                     Assert.assertEquals(expX, $noinline$indexOf(full, 'x', -1));
519                     Assert.assertEquals(exp0440, $noinline$indexOf(full, '\u0440', -1));
520                     Assert.assertEquals(exp0000, $noinline$indexOf(full, '\u0000', -1));
521                     Assert.assertEquals(-1, $noinline$indexOf(full, 'x', full.length() + 1));
522                     Assert.assertEquals(-1, $noinline$indexOf(full, '\u0440', full.length() + 1));
523                     Assert.assertEquals(-1, $noinline$indexOf(full, '\u0000', full.length() + 1));
524                     for (int from = 0; from != full.length(); ++from) {
525                         final int eX;
526                         final int e0440;
527                         final int e0000;
528                         if (from <= p.length()) {
529                             eX = expX;
530                             e0440 = exp0440;
531                             e0000 = exp0000;
532                         } else if (from >= p.length() + c.length()) {
533                             eX = -1;
534                             e0440 = -1;
535                             e0000 = -1;
536                         } else if (full.charAt(from) == 'z') {
537                             eX = (full.charAt(from + 1) != 'x') ? -1 : from + 1;
538                             e0440 = (full.charAt(from + 1) != '\u0440') ? -1 : from + 1;
539                             e0000 = (full.charAt(from + 1) != '\u0000') ? -1 : from + 1;
540                         } else {
541                             eX = (full.charAt(from) != 'x') ? -1 : from;
542                             e0440 = (full.charAt(from) != '\u0440') ? -1 : from;
543                             e0000 = (full.charAt(from) != '\u0000') ? -1 : from;
544                         }
545                         Assert.assertEquals(eX, $noinline$indexOf(full, 'x', from));
546                         Assert.assertEquals(e0440, $noinline$indexOf(full, '\u0440', from));
547                         Assert.assertEquals(e0000, $noinline$indexOf(full, '\u0000', from));
548                     }
549                 }
550             }
551         }
552     }
553 
testEqualsConstString()554     public static void testEqualsConstString() {
555         Assert.assertTrue($noinline$equalsConstString0(""));
556         Assert.assertFalse($noinline$equalsConstString0("1"));
557 
558         Assert.assertTrue($noinline$equalsConstString3("012"));
559         Assert.assertFalse($noinline$equalsConstString3("01"));
560         Assert.assertFalse($noinline$equalsConstString3("0123"));
561         Assert.assertFalse($noinline$equalsConstString3("01x"));
562         Assert.assertFalse($noinline$equalsConstString3("01\u0440"));
563 
564         Assert.assertTrue($noinline$equalsConstString7("0123456"));
565         Assert.assertFalse($noinline$equalsConstString7("012345"));
566         Assert.assertFalse($noinline$equalsConstString7("01234567"));
567         Assert.assertFalse($noinline$equalsConstString7("012345x"));
568         Assert.assertFalse($noinline$equalsConstString7("012345\u0440"));
569 
570         Assert.assertTrue($noinline$equalsConstString12("012345678901"));
571         Assert.assertFalse($noinline$equalsConstString12("01234567890"));
572         Assert.assertFalse($noinline$equalsConstString12("0123456789012"));
573         Assert.assertFalse($noinline$equalsConstString12("01234567890x"));
574         Assert.assertFalse($noinline$equalsConstString12("01234567890\u0440"));
575 
576         Assert.assertTrue($noinline$equalsConstString14("01234567890123"));
577         Assert.assertFalse($noinline$equalsConstString14("0123456789012"));
578         Assert.assertFalse($noinline$equalsConstString14("012345678901234"));
579         Assert.assertFalse($noinline$equalsConstString14("0123456789012x"));
580         Assert.assertFalse($noinline$equalsConstString14("0123456789012\u0440"));
581 
582         Assert.assertTrue($noinline$equalsConstString24("012345678901234567890123"));
583         Assert.assertFalse($noinline$equalsConstString24("01234567890123456789012"));
584         Assert.assertFalse($noinline$equalsConstString24("0123456789012345678901234"));
585         Assert.assertFalse($noinline$equalsConstString24("01234567890123456789012x"));
586         Assert.assertFalse($noinline$equalsConstString24("01234567890123456789012\u0440"));
587 
588         Assert.assertTrue($noinline$equalsConstString29("01234567890123456789012345678"));
589         Assert.assertFalse($noinline$equalsConstString29("0123456789012345678901234567"));
590         Assert.assertFalse($noinline$equalsConstString29("012345678901234567890123456789"));
591         Assert.assertFalse($noinline$equalsConstString29("0123456789012345678901234567x"));
592         Assert.assertFalse($noinline$equalsConstString29("0123456789012345678901234567\u0440"));
593 
594         Assert.assertTrue($noinline$equalsConstString35("01234567890123456789012345678901234"));
595         Assert.assertFalse($noinline$equalsConstString35("0123456789012345678901234567890123"));
596         Assert.assertFalse($noinline$equalsConstString35("012345678901234567890123456789012345"));
597         Assert.assertFalse($noinline$equalsConstString35("0123456789012345678901234567890123x"));
598         Assert.assertFalse(
599             $noinline$equalsConstString35("0123456789012345678901234567890123\u0440"));
600 
601         Assert.assertTrue($noinline$equalsConstNonAsciiString3("\u044012"));
602         Assert.assertFalse($noinline$equalsConstNonAsciiString3("\u04401"));
603         Assert.assertFalse($noinline$equalsConstNonAsciiString3("\u0440123"));
604         Assert.assertFalse($noinline$equalsConstNonAsciiString3("\u04401x"));
605         Assert.assertFalse($noinline$equalsConstNonAsciiString3("012"));
606 
607         Assert.assertTrue($noinline$equalsConstNonAsciiString7("\u0440123456"));
608         Assert.assertFalse($noinline$equalsConstNonAsciiString7("\u044012345"));
609         Assert.assertFalse($noinline$equalsConstNonAsciiString7("\u04401234567"));
610         Assert.assertFalse($noinline$equalsConstNonAsciiString7("\u044012345x"));
611         Assert.assertFalse($noinline$equalsConstNonAsciiString7("0123456"));
612 
613         Assert.assertTrue($noinline$equalsConstNonAsciiString12("\u044012345678901"));
614         Assert.assertFalse($noinline$equalsConstNonAsciiString12("\u04401234567890"));
615         Assert.assertFalse($noinline$equalsConstNonAsciiString12("\u0440123456789012"));
616         Assert.assertFalse($noinline$equalsConstNonAsciiString12("\u04401234567890x"));
617         Assert.assertFalse($noinline$equalsConstNonAsciiString12("012345678901"));
618 
619         Assert.assertTrue($noinline$equalsConstNonAsciiString14("\u04401234567890123"));
620         Assert.assertFalse($noinline$equalsConstNonAsciiString14("\u0440123456789012"));
621         Assert.assertFalse($noinline$equalsConstNonAsciiString14("\u044012345678901234"));
622         Assert.assertFalse($noinline$equalsConstNonAsciiString14("\u0440123456789012x"));
623         Assert.assertFalse($noinline$equalsConstNonAsciiString14("01234567890123"));
624 
625         Assert.assertTrue($noinline$equalsConstNonAsciiString24("\u044012345678901234567890123"));
626         Assert.assertFalse($noinline$equalsConstNonAsciiString24("\u04401234567890123456789012"));
627         Assert.assertFalse($noinline$equalsConstNonAsciiString24("\u0440123456789012345678901234"));
628         Assert.assertFalse($noinline$equalsConstNonAsciiString24("\u04401234567890123456789012x"));
629         Assert.assertFalse($noinline$equalsConstNonAsciiString24("\012345678901234567890123"));
630 
631         Assert.assertTrue(
632             $noinline$equalsConstNonAsciiString29("\u04401234567890123456789012345678"));
633         Assert.assertFalse(
634             $noinline$equalsConstNonAsciiString29("\u0440123456789012345678901234567"));
635         Assert.assertFalse(
636             $noinline$equalsConstNonAsciiString29("\u044012345678901234567890123456789"));
637         Assert.assertFalse(
638             $noinline$equalsConstNonAsciiString29("\u0440123456789012345678901234567x"));
639         Assert.assertFalse($noinline$equalsConstNonAsciiString29("01234567890123456789012345678"));
640 
641         Assert.assertTrue(
642             $noinline$equalsConstNonAsciiString35("\u04401234567890123456789012345678901234"));
643         Assert.assertFalse(
644             $noinline$equalsConstNonAsciiString35("\u0440123456789012345678901234567890123"));
645         Assert.assertFalse(
646             $noinline$equalsConstNonAsciiString35("\u044012345678901234567890123456789012345"));
647         Assert.assertFalse(
648             $noinline$equalsConstNonAsciiString35("\u0440123456789012345678901234567890123x"));
649         Assert.assertFalse(
650             $noinline$equalsConstNonAsciiString35("01234567890123456789012345678901234"));
651     }
652 
testConstStringEquals()653     public static void testConstStringEquals() {
654         Assert.assertTrue($noinline$constString0Equals(""));
655         Assert.assertFalse($noinline$constString0Equals("1"));
656 
657         Assert.assertTrue($noinline$constString3Equals("012"));
658         Assert.assertFalse($noinline$constString3Equals("01"));
659         Assert.assertFalse($noinline$constString3Equals("0123"));
660         Assert.assertFalse($noinline$constString3Equals("01x"));
661         Assert.assertFalse($noinline$constString3Equals("01\u0440"));
662 
663         Assert.assertTrue($noinline$constString7Equals("0123456"));
664         Assert.assertFalse($noinline$constString7Equals("012345"));
665         Assert.assertFalse($noinline$constString7Equals("01234567"));
666         Assert.assertFalse($noinline$constString7Equals("012345x"));
667         Assert.assertFalse($noinline$constString7Equals("012345\u0440"));
668 
669         Assert.assertTrue($noinline$constString12Equals("012345678901"));
670         Assert.assertFalse($noinline$constString12Equals("01234567890"));
671         Assert.assertFalse($noinline$constString12Equals("0123456789012"));
672         Assert.assertFalse($noinline$constString12Equals("01234567890x"));
673         Assert.assertFalse($noinline$constString12Equals("01234567890\u0440"));
674 
675         Assert.assertTrue($noinline$constString14Equals("01234567890123"));
676         Assert.assertFalse($noinline$constString14Equals("0123456789012"));
677         Assert.assertFalse($noinline$constString14Equals("012345678901234"));
678         Assert.assertFalse($noinline$constString14Equals("0123456789012x"));
679         Assert.assertFalse($noinline$constString14Equals("0123456789012\u0440"));
680 
681         Assert.assertTrue($noinline$constString24Equals("012345678901234567890123"));
682         Assert.assertFalse($noinline$constString24Equals("01234567890123456789012"));
683         Assert.assertFalse($noinline$constString24Equals("0123456789012345678901234"));
684         Assert.assertFalse($noinline$constString24Equals("01234567890123456789012x"));
685         Assert.assertFalse($noinline$constString24Equals("01234567890123456789012\u0440"));
686 
687         Assert.assertTrue($noinline$constString29Equals("01234567890123456789012345678"));
688         Assert.assertFalse($noinline$constString29Equals("0123456789012345678901234567"));
689         Assert.assertFalse($noinline$constString29Equals("012345678901234567890123456789"));
690         Assert.assertFalse($noinline$constString29Equals("0123456789012345678901234567x"));
691         Assert.assertFalse($noinline$constString29Equals("0123456789012345678901234567\u0440"));
692 
693         Assert.assertTrue($noinline$constString35Equals("01234567890123456789012345678901234"));
694         Assert.assertFalse($noinline$constString35Equals("0123456789012345678901234567890123"));
695         Assert.assertFalse($noinline$constString35Equals("012345678901234567890123456789012345"));
696         Assert.assertFalse($noinline$constString35Equals("0123456789012345678901234567890123x"));
697         Assert.assertFalse(
698             $noinline$constString35Equals("0123456789012345678901234567890123\u0040"));
699 
700         Assert.assertTrue($noinline$constNonAsciiString3Equals("\u044012"));
701         Assert.assertFalse($noinline$constNonAsciiString3Equals("\u04401"));
702         Assert.assertFalse($noinline$constNonAsciiString3Equals("\u0440123"));
703         Assert.assertFalse($noinline$constNonAsciiString3Equals("\u04401x"));
704         Assert.assertFalse($noinline$constNonAsciiString3Equals("0123456"));
705 
706         Assert.assertTrue($noinline$constNonAsciiString7Equals("\u0440123456"));
707         Assert.assertFalse($noinline$constNonAsciiString7Equals("\u044012345"));
708         Assert.assertFalse($noinline$constNonAsciiString7Equals("\u04401234567"));
709         Assert.assertFalse($noinline$constNonAsciiString7Equals("\u044012345x"));
710         Assert.assertFalse($noinline$constNonAsciiString7Equals("0123456"));
711 
712         Assert.assertTrue($noinline$constNonAsciiString12Equals("\u044012345678901"));
713         Assert.assertFalse($noinline$constNonAsciiString12Equals("\u04401234567890"));
714         Assert.assertFalse($noinline$constNonAsciiString12Equals("\u0440123456789012"));
715         Assert.assertFalse($noinline$constNonAsciiString12Equals("\u04401234567890x"));
716         Assert.assertFalse($noinline$constNonAsciiString12Equals("012345678901"));
717 
718         Assert.assertTrue($noinline$constNonAsciiString14Equals("\u04401234567890123"));
719         Assert.assertFalse($noinline$constNonAsciiString14Equals("\u0440123456789012"));
720         Assert.assertFalse($noinline$constNonAsciiString14Equals("\u044012345678901234"));
721         Assert.assertFalse($noinline$constNonAsciiString14Equals("\u0440123456789012x"));
722         Assert.assertFalse($noinline$constNonAsciiString14Equals("01234567890123"));
723 
724         Assert.assertTrue($noinline$constNonAsciiString24Equals("\u044012345678901234567890123"));
725         Assert.assertFalse($noinline$constNonAsciiString24Equals("\u04401234567890123456789012"));
726         Assert.assertFalse($noinline$constNonAsciiString24Equals("\u0440123456789012345678901234"));
727         Assert.assertFalse($noinline$constNonAsciiString24Equals("\u04401234567890123456789012x"));
728         Assert.assertFalse($noinline$constNonAsciiString24Equals("\012345678901234567890123"));
729 
730         Assert.assertTrue(
731             $noinline$constNonAsciiString29Equals("\u04401234567890123456789012345678"));
732         Assert.assertFalse(
733             $noinline$constNonAsciiString29Equals("\u0440123456789012345678901234567"));
734         Assert.assertFalse(
735             $noinline$constNonAsciiString29Equals("\u044012345678901234567890123456789"));
736         Assert.assertFalse(
737             $noinline$constNonAsciiString29Equals("\u0440123456789012345678901234567x"));
738         Assert.assertFalse($noinline$constNonAsciiString29Equals("01234567890123456789012345678"));
739 
740         Assert.assertTrue(
741             $noinline$constNonAsciiString35Equals("\u04401234567890123456789012345678901234"));
742         Assert.assertFalse(
743             $noinline$constNonAsciiString35Equals("\u0440123456789012345678901234567890123"));
744         Assert.assertFalse(
745             $noinline$constNonAsciiString35Equals("\u044012345678901234567890123456789012345"));
746         Assert.assertFalse(
747             $noinline$constNonAsciiString35Equals("\u0440123456789012345678901234567890123x"));
748         Assert.assertFalse(
749             $noinline$constNonAsciiString35Equals("01234567890123456789012345678901234"));
750 
751         // Regression test for incorrectly creating an uncompressed string when the
752         // string should be compressed. Only the low 8 bits are relevant but the whole
753         // `hibyte` was erroneously tested. Bug: 63661357
754         Assert.assertTrue("A".equals(new String(new byte[] { (byte)'A' }, /* hibyte */ 0x100)));
755     }
756 
testStringConcat()757     public static void testStringConcat() {
758         Assert.assertEquals("abcxyzw", "abc".concat("xyzw"));
759         Assert.assertEquals("abc\u0440", "abc".concat("\u0440"));
760         Assert.assertEquals("\u0440xyzw", "\u0440".concat("xyzw"));
761         Assert.assertEquals("abc\u0440xyzw\u0440", "abc\u0440".concat("xyzw\u0440"));
762     }
763 
testEmptyWithHighByte()764     public static void testEmptyWithHighByte() {
765         String empty = new String(new byte[0], 1);
766         Assert.assertEquals("", empty);
767     }
768 
$noinline$equalsConstString0(String s)769     public static boolean $noinline$equalsConstString0(String s) {
770         return s.equals("");
771     }
772 
$noinline$equalsConstString3(String s)773     public static boolean $noinline$equalsConstString3(String s) {
774         return s.equals("012");
775     }
776 
$noinline$equalsConstString7(String s)777     public static boolean $noinline$equalsConstString7(String s) {
778         return s.equals("0123456");
779     }
780 
$noinline$equalsConstString12(String s)781     public static boolean $noinline$equalsConstString12(String s) {
782         return s.equals("012345678901");
783     }
784 
$noinline$equalsConstString14(String s)785     public static boolean $noinline$equalsConstString14(String s) {
786         return s.equals("01234567890123");
787     }
788 
$noinline$equalsConstString24(String s)789     public static boolean $noinline$equalsConstString24(String s) {
790         return s.equals("012345678901234567890123");
791     }
792 
$noinline$equalsConstString29(String s)793     public static boolean $noinline$equalsConstString29(String s) {
794         return s.equals("01234567890123456789012345678");
795     }
796 
$noinline$equalsConstString35(String s)797     public static boolean $noinline$equalsConstString35(String s) {
798         return s.equals("01234567890123456789012345678901234");
799     }
800 
$noinline$equalsConstNonAsciiString3(String s)801     public static boolean $noinline$equalsConstNonAsciiString3(String s) {
802         return s.equals("\u044012");
803     }
804 
$noinline$equalsConstNonAsciiString7(String s)805     public static boolean $noinline$equalsConstNonAsciiString7(String s) {
806         return s.equals("\u0440123456");
807     }
808 
$noinline$equalsConstNonAsciiString12(String s)809     public static boolean $noinline$equalsConstNonAsciiString12(String s) {
810         return s.equals("\u044012345678901");
811     }
812 
$noinline$equalsConstNonAsciiString14(String s)813     public static boolean $noinline$equalsConstNonAsciiString14(String s) {
814         return s.equals("\u04401234567890123");
815     }
816 
$noinline$equalsConstNonAsciiString24(String s)817     public static boolean $noinline$equalsConstNonAsciiString24(String s) {
818         return s.equals("\u044012345678901234567890123");
819     }
820 
$noinline$equalsConstNonAsciiString29(String s)821     public static boolean $noinline$equalsConstNonAsciiString29(String s) {
822         return s.equals("\u04401234567890123456789012345678");
823     }
824 
$noinline$equalsConstNonAsciiString35(String s)825     public static boolean $noinline$equalsConstNonAsciiString35(String s) {
826         return s.equals("\u04401234567890123456789012345678901234");
827     }
828 
$noinline$constString0Equals(String s)829     public static boolean $noinline$constString0Equals(String s) {
830         return s.equals("");
831     }
832 
$noinline$constString3Equals(String s)833     public static boolean $noinline$constString3Equals(String s) {
834         return "012".equals(s);
835     }
836 
$noinline$constString7Equals(String s)837     public static boolean $noinline$constString7Equals(String s) {
838         return "0123456".equals(s);
839     }
840 
$noinline$constString12Equals(String s)841     public static boolean $noinline$constString12Equals(String s) {
842         return "012345678901".equals(s);
843     }
844 
$noinline$constString14Equals(String s)845     public static boolean $noinline$constString14Equals(String s) {
846         return "01234567890123".equals(s);
847     }
848 
$noinline$constString24Equals(String s)849     public static boolean $noinline$constString24Equals(String s) {
850         return "012345678901234567890123".equals(s);
851     }
852 
$noinline$constString29Equals(String s)853     public static boolean $noinline$constString29Equals(String s) {
854         return "01234567890123456789012345678".equals(s);
855     }
856 
$noinline$constString35Equals(String s)857     public static boolean $noinline$constString35Equals(String s) {
858         return "01234567890123456789012345678901234".equals(s);
859     }
860 
$noinline$constNonAsciiString3Equals(String s)861     public static boolean $noinline$constNonAsciiString3Equals(String s) {
862         return "\u044012".equals(s);
863     }
864 
$noinline$constNonAsciiString7Equals(String s)865     public static boolean $noinline$constNonAsciiString7Equals(String s) {
866         return "\u0440123456".equals(s);
867     }
868 
$noinline$constNonAsciiString12Equals(String s)869     public static boolean $noinline$constNonAsciiString12Equals(String s) {
870         return "\u044012345678901".equals(s);
871     }
872 
$noinline$constNonAsciiString14Equals(String s)873     public static boolean $noinline$constNonAsciiString14Equals(String s) {
874         return "\u04401234567890123".equals(s);
875     }
876 
$noinline$constNonAsciiString24Equals(String s)877     public static boolean $noinline$constNonAsciiString24Equals(String s) {
878         return "\u044012345678901234567890123".equals(s);
879     }
880 
$noinline$constNonAsciiString29Equals(String s)881     public static boolean $noinline$constNonAsciiString29Equals(String s) {
882         return "\u04401234567890123456789012345678".equals(s);
883     }
884 
$noinline$constNonAsciiString35Equals(String s)885     public static boolean $noinline$constNonAsciiString35Equals(String s) {
886         return "\u04401234567890123456789012345678901234".equals(s);
887     }
888 
$noinline$compareTo(String lhs, String rhs)889     public static int $noinline$compareTo(String lhs, String rhs) {
890         return lhs.compareTo(rhs);
891     }
892 
$noinline$equals(String lhs, String rhs)893     public static boolean $noinline$equals(String lhs, String rhs) {
894         return lhs.equals(rhs);
895     }
896 
$noinline$indexOf(String lhs, int ch)897     public static int $noinline$indexOf(String lhs, int ch) {
898         return lhs.indexOf(ch);
899     }
900 
$noinline$indexOf(String lhs, int ch, int fromIndex)901     public static int $noinline$indexOf(String lhs, int ch, int fromIndex) {
902         return lhs.indexOf(ch, fromIndex);
903     }
904 }
905