114     Assert.assertEquals(str0.length(), 0);  in test_String_length()
115     Assert.assertEquals(str1.length(), 1);  in test_String_length()
116     Assert.assertEquals(str80.length(), 80);  in test_String_length()
147     Assert.assertEquals(testStr.length() - 1, 33);  // 33 = testStr.length()-1 as a constant.  in test_String_charAt()
148     Assert.assertEquals('f', testStr.charAt(33));  in test_String_charAt()
154     Assert.assertEquals(a, testStr.charAt(0));  in test_String_charAt()
155     Assert.assertEquals(b, testStr.charAt(1));  in test_String_charAt()
156     Assert.assertEquals(c, testStr.charAt(10));  in test_String_charAt()
157     Assert.assertEquals(d, testStr.charAt(testStr.length()-1));  in test_String_charAt()
178           Assert.assertEquals(testStr.length(), 12);  // 12 = " is the time".length()  in test_String_charAtExc()
199         Assert.assertEquals(testStr.length(), 12);  // 12 = " is the time".length()  in test_String_charAtExc()
240     Assert.assertEquals('N', testStr.charAt(-1));  in test_String_charAtExc3()
244     Assert.assertEquals('N', testStr.charAt(100));  in test_String_charAtExc4()
256     Assert.assertEquals(str0.indexOf('a'), -1);  in test_String_indexOf()
257     Assert.assertEquals(str3.indexOf('a'), 0);  in test_String_indexOf()
258     Assert.assertEquals(str3.indexOf('b'), 1);  in test_String_indexOf()
259     Assert.assertEquals(str3.indexOf('c'), 2);  in test_String_indexOf()
260     Assert.assertEquals(str10.indexOf('j'), 9);  in test_String_indexOf()
261     Assert.assertEquals(str40.indexOf('a'), 0);  in test_String_indexOf()
262     Assert.assertEquals(str40.indexOf('b'), 38);  in test_String_indexOf()
263     Assert.assertEquals(str40.indexOf('c'), 39);  in test_String_indexOf()
264     Assert.assertEquals(str0.indexOf('a',20), -1);  in test_String_indexOf()
265     Assert.assertEquals(str0.indexOf('a',0), -1);  in test_String_indexOf()
266     Assert.assertEquals(str0.indexOf('a',-1), -1);  in test_String_indexOf()
267     Assert.assertEquals(str1.indexOf('/',++start), -1);  in test_String_indexOf()
268     Assert.assertEquals(str1.indexOf('a',negIndex[0]), -1);  in test_String_indexOf()
269     Assert.assertEquals(str3.indexOf('a',0), 0);  in test_String_indexOf()
270     Assert.assertEquals(str3.indexOf('a',1), -1);  in test_String_indexOf()
271     Assert.assertEquals(str3.indexOf('a',1234), -1);  in test_String_indexOf()
272     Assert.assertEquals(str3.indexOf('b',0), 1);  in test_String_indexOf()
273     Assert.assertEquals(str3.indexOf('b',1), 1);  in test_String_indexOf()
274     Assert.assertEquals(str3.indexOf('c',2), 2);  in test_String_indexOf()
275     Assert.assertEquals(str10.indexOf('j',5), 9);  in test_String_indexOf()
276     Assert.assertEquals(str10.indexOf('j',9), 9);  in test_String_indexOf()
277     Assert.assertEquals(str40.indexOf('a',10), 10);  in test_String_indexOf()
278     Assert.assertEquals(str40.indexOf('b',40), -1);  in test_String_indexOf()
331     Assert.assertEquals(str0.indexOf(searchData[0][0]), searchData[0][2]);  in testStringIndexOfCharsImpl()
332     Assert.assertEquals(str3.indexOf(searchData[1][0]), searchData[1][2]);  in testStringIndexOfCharsImpl()
333     Assert.assertEquals(str3.indexOf(searchData[2][0]), searchData[2][2]);  in testStringIndexOfCharsImpl()
334     Assert.assertEquals(str3.indexOf(searchData[3][0]), searchData[3][2]);  in testStringIndexOfCharsImpl()
335     Assert.assertEquals(str10.indexOf(searchData[4][0]), searchData[4][2]);  in testStringIndexOfCharsImpl()
336     Assert.assertEquals(str40.indexOf(searchData[5][0]), searchData[5][2]);  in testStringIndexOfCharsImpl()
337     Assert.assertEquals(str40.indexOf(searchData[6][0]), searchData[6][2]);  in testStringIndexOfCharsImpl()
338     Assert.assertEquals(str40.indexOf(searchData[7][0]), searchData[7][2]);  in testStringIndexOfCharsImpl()
339     Assert.assertEquals(str0.indexOf(searchData[8][0], searchData[8][1]), searchData[8][2]);  in testStringIndexOfCharsImpl()
340     Assert.assertEquals(str0.indexOf(searchData[9][0], searchData[9][1]), searchData[9][2]);  in testStringIndexOfCharsImpl()
341     Assert.assertEquals(str0.indexOf(searchData[10][0], searchData[10][1]), searchData[10][2]);  in testStringIndexOfCharsImpl()
342     Assert.assertEquals(str1.indexOf(searchData[11][0], searchData[11][1]), searchData[11][2]);  in testStringIndexOfCharsImpl()
343     Assert.assertEquals(str1.indexOf(searchData[12][0], searchData[12][1]), searchData[12][2]);  in testStringIndexOfCharsImpl()
344     Assert.assertEquals(str3.indexOf(searchData[13][0], searchData[13][1]), searchData[13][2]);  in testStringIndexOfCharsImpl()
345     Assert.assertEquals(str3.indexOf(searchData[14][0], searchData[14][1]), searchData[14][2]);  in testStringIndexOfCharsImpl()
346     Assert.assertEquals(str3.indexOf(searchData[15][0], searchData[15][1]), searchData[15][2]);  in testStringIndexOfCharsImpl()
347     Assert.assertEquals(str3.indexOf(searchData[16][0], searchData[16][1]), searchData[16][2]);  in testStringIndexOfCharsImpl()
348     Assert.assertEquals(str3.indexOf(searchData[17][0], searchData[17][1]), searchData[17][2]);  in testStringIndexOfCharsImpl()
349     Assert.assertEquals(str3.indexOf(searchData[18][0], searchData[18][1]), searchData[18][2]);  in testStringIndexOfCharsImpl()
350     Assert.assertEquals(str10.indexOf(searchData[19][0], searchData[19][1]), searchData[19][2]);  in testStringIndexOfCharsImpl()
351     Assert.assertEquals(str10.indexOf(searchData[20][0], searchData[20][1]), searchData[20][2]);  in testStringIndexOfCharsImpl()
352     Assert.assertEquals(str40.indexOf(searchData[21][0], searchData[21][1]), searchData[21][2]);  in testStringIndexOfCharsImpl()
353     Assert.assertEquals(str40.indexOf(searchData[22][0], searchData[22][1]), searchData[22][2]);  in testStringIndexOfCharsImpl()
361     Assert.assertEquals(stringWithSurrogates.indexOf(supplementaryChar), "hello ".length());  in testSurrogateIndexOf()
362     Assert.assertEquals(stringWithSurrogates.indexOf(supplementaryChar, 2), "hello ".length());  in testSurrogateIndexOf()
363     Assert.assertEquals(stringWithSurrogates.indexOf(supplementaryChar, 6), 6);  in testSurrogateIndexOf()
364     Assert.assertEquals(stringWithSurrogates.indexOf(supplementaryChar, 7), -1);  in testSurrogateIndexOf()
366     Assert.assertEquals(stringWithSurrogates.indexOf(supplementaryChar - 0x10000), -1);  in testSurrogateIndexOf()
367     Assert.assertEquals(stringWithSurrogates.indexOf(supplementaryChar | 0x80000000), -1);  in testSurrogateIndexOf()
411     Assert.assertEquals(str32.compareTo(str33), -1);  in test_String_compareTo()
412     Assert.assertEquals(str33.compareTo(str32), 1);  in test_String_compareTo()
418     Assert.assertEquals(test.compareTo(test1), 0);  in test_String_compareTo()
423     Assert.assertEquals(test.compareTo(sub), 0);  in test_String_compareTo()
424     Assert.assertEquals(sub.compareTo(test), 0);  in test_String_compareTo()
460     Assert.assertEquals(4, strings.length);  in test_String_compareTo()
462     Assert.assertEquals("this is a path", test.replaceAll("/", " "));  in test_String_compareTo()
463     Assert.assertEquals("this is a path", test.replace("/", " "));  in test_String_compareTo()
468     Assert.assertEquals(Math.abs(0), 0);
469     Assert.assertEquals(Math.abs(123), 123);
470     Assert.assertEquals(Math.abs(-123), 123);
471     Assert.assertEquals(Math.abs(Integer.MAX_VALUE), Integer.MAX_VALUE);
472     Assert.assertEquals(Math.abs(Integer.MIN_VALUE), Integer.MIN_VALUE);
473     Assert.assertEquals(Math.abs(Integer.MIN_VALUE - 1), Integer.MAX_VALUE);
474     Assert.assertEquals(Math.abs(Integer.MIN_VALUE + 1), Integer.MAX_VALUE);
479     Assert.assertEquals(Math.abs(0L), 0L);
480     Assert.assertEquals(Math.abs(123L), 123L);
481     Assert.assertEquals(Math.abs(-123L), 123L);
482     Assert.assertEquals(Math.abs(Long.MAX_VALUE), Long.MAX_VALUE);
483     Assert.assertEquals(Math.abs(Long.MIN_VALUE), Long.MIN_VALUE);
484     Assert.assertEquals(Math.abs(Long.MIN_VALUE - 1), Long.MAX_VALUE);
485     Assert.assertEquals(Math.abs(2147483648L), 2147483648L);
490     Assert.assertEquals(Math.min(0, 0), 0);
491     Assert.assertEquals(Math.min(1, 0), 0);
492     Assert.assertEquals(Math.min(0, 1), 0);
493     Assert.assertEquals(Math.min(0, Integer.MAX_VALUE), 0);
494     Assert.assertEquals(Math.min(Integer.MIN_VALUE, 0), Integer.MIN_VALUE);
495     Assert.assertEquals(Math.min(Integer.MIN_VALUE, Integer.MAX_VALUE), Integer.MIN_VALUE);
500     Assert.assertEquals(Math.max(0, 0), 0);
501     Assert.assertEquals(Math.max(1, 0), 1);
502     Assert.assertEquals(Math.max(0, 1), 1);
503     Assert.assertEquals(Math.max(0, Integer.MAX_VALUE), Integer.MAX_VALUE);
504     Assert.assertEquals(Math.max(Integer.MIN_VALUE, 0), 0);
505     Assert.assertEquals(Math.max(Integer.MIN_VALUE, Integer.MAX_VALUE), Integer.MAX_VALUE);
510     Assert.assertEquals(Math.min(0L, 0L), 0L);
511     Assert.assertEquals(Math.min(1L, 0L), 0L);
512     Assert.assertEquals(Math.min(0L, 1L), 0L);
513     Assert.assertEquals(Math.min(0L, Long.MAX_VALUE), 0L);
514     Assert.assertEquals(Math.min(Long.MIN_VALUE, 0L), Long.MIN_VALUE);
515     Assert.assertEquals(Math.min(Long.MIN_VALUE, Long.MAX_VALUE), Long.MIN_VALUE);
520     Assert.assertEquals(Math.max(0L, 0L), 0L);
521     Assert.assertEquals(Math.max(1L, 0L), 1L);
522     Assert.assertEquals(Math.max(0L, 1L), 1L);
523     Assert.assertEquals(Math.max(0L, Long.MAX_VALUE), Long.MAX_VALUE);
524     Assert.assertEquals(Math.max(Long.MIN_VALUE, 0L), 0L);
525     Assert.assertEquals(Math.max(Long.MIN_VALUE, Long.MAX_VALUE), Long.MAX_VALUE);
532     Assert.assertEquals(Math.min(-0.0f, 0.0f), -0.0f);
533     Assert.assertEquals(Math.min(0.0f, -0.0f), -0.0f);
534     Assert.assertEquals(Math.min(-0.0f, -0.0f), -0.0f);
535     Assert.assertEquals(Math.min(0.0f, 0.0f), 0.0f);
536     Assert.assertEquals(Math.min(1.0f, 0.0f), 0.0f);
537     Assert.assertEquals(Math.min(0.0f, 1.0f), 0.0f);
538     Assert.assertEquals(Math.min(0.0f, Float.MAX_VALUE), 0.0f);
539     Assert.assertEquals(Math.min(Float.MIN_VALUE, 0.0f), 0.0f);
540     Assert.assertEquals(Math.min(Float.MIN_VALUE, Float.MAX_VALUE), Float.MIN_VALUE);
542     Assert.assertEquals(Math.min(Float.MIN_VALUE, Float.MIN_VALUE), Float.MIN_VALUE);
549     Assert.assertEquals(Math.max(-0.0f, 0.0f), 0.0f);
550     Assert.assertEquals(Math.max(0.0f, -0.0f), 0.0f);
551     Assert.assertEquals(Math.max(-0.0f, -0.0f), -0.0f);
552     Assert.assertEquals(Math.max(0.0f, 0.0f), 0.0f);
553     Assert.assertEquals(Math.max(1.0f, 0.0f), 1.0f);
554     Assert.assertEquals(Math.max(0.0f, 1.0f), 1.0f);
555     Assert.assertEquals(Math.max(0.0f, Float.MAX_VALUE), Float.MAX_VALUE);
556     Assert.assertEquals(Math.max(Float.MIN_VALUE, Float.MAX_VALUE), Float.MAX_VALUE);
558     Assert.assertEquals(Math.max(Float.MIN_VALUE, 0.0f), Float.MIN_VALUE);
559     Assert.assertEquals(Math.max(Float.MIN_VALUE, Float.MIN_VALUE), Float.MIN_VALUE);
566     Assert.assertEquals(Math.min(-0.0d, 0.0d), -0.0d);
567     Assert.assertEquals(Math.min(0.0d, -0.0d), -0.0d);
568     Assert.assertEquals(Math.min(-0.0d, -0.0d), -0.0d);
569     Assert.assertEquals(Math.min(0.0d, 0.0d), 0.0d);
570     Assert.assertEquals(Math.min(1.0d, 0.0d), 0.0d);
571     Assert.assertEquals(Math.min(0.0d, 1.0d), 0.0d);
572     Assert.assertEquals(Math.min(0.0d, Double.MAX_VALUE), 0.0d);
573     Assert.assertEquals(Math.min(Double.MIN_VALUE, 0.0d), 0.0d);
574     Assert.assertEquals(Math.min(Double.MIN_VALUE, Double.MAX_VALUE), Double.MIN_VALUE);
576     Assert.assertEquals(Math.min(Double.MIN_VALUE, Double.MIN_VALUE), Double.MIN_VALUE);
583     Assert.assertEquals(Math.max(-0.0d, 0.0d), 0.0d);
584     Assert.assertEquals(Math.max(0.0d, -0.0d), 0.0d);
585     Assert.assertEquals(Math.max(-0.0d, -0.0d), -0.0d);
586     Assert.assertEquals(Math.max(0.0d, 0.0d), 0.0d);
587     Assert.assertEquals(Math.max(1.0d, 0.0d), 1.0d);
588     Assert.assertEquals(Math.max(0.0d, 1.0d), 1.0d);
589     Assert.assertEquals(Math.max(0.0d, Double.MAX_VALUE), Double.MAX_VALUE);
590     Assert.assertEquals(Math.max(Double.MIN_VALUE, 0.0d), Double.MIN_VALUE);
591     Assert.assertEquals(Math.max(Double.MIN_VALUE, Double.MAX_VALUE), Double.MAX_VALUE);
593     Assert.assertEquals(Math.max(Double.MIN_VALUE, 0.0d), Double.MIN_VALUE);
594     Assert.assertEquals(Math.max(Double.MIN_VALUE, Double.MIN_VALUE), Double.MIN_VALUE);
599     Assert.assertEquals(Math.sqrt(+4.0), +2.0d, 0.0);
600     Assert.assertEquals(Math.sqrt(+49.0), +7.0d, 0.0);
601     Assert.assertEquals(Math.sqrt(+1.44), +1.2d, 0.0);
606     Assert.assertEquals(Math.ceil(+0.0), +0.0d, 0.0);
607     Assert.assertEquals(Math.ceil(-0.0), -0.0d, 0.0);
608     Assert.assertEquals(Math.ceil(-0.9), -0.0d, 0.0);
609     Assert.assertEquals(Math.ceil(-0.5), -0.0d, 0.0);
610     Assert.assertEquals(Math.ceil(0.0), -0.0d, 0.0);
611     Assert.assertEquals(Math.ceil(+2.0), +2.0d, 0.0);
612     Assert.assertEquals(Math.ceil(+2.1), +3.0d, 0.0);
613     Assert.assertEquals(Math.ceil(+2.5), +3.0d, 0.0);
614     Assert.assertEquals(Math.ceil(+2.9), +3.0d, 0.0);
615     Assert.assertEquals(Math.ceil(+3.0), +3.0d, 0.0);
616     Assert.assertEquals(Math.ceil(-2.0), -2.0d, 0.0);
617     Assert.assertEquals(Math.ceil(-2.1), -2.0d, 0.0);
618     Assert.assertEquals(Math.ceil(-2.5), -2.0d, 0.0);
619     Assert.assertEquals(Math.ceil(-2.9), -2.0d, 0.0);
620     Assert.assertEquals(Math.ceil(-3.0), -3.0d, 0.0);
622     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0x432FFFFFFFFFFFFDl)),
625     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0x432FFFFFFFFFFFFFl)),
628     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0x4330000000000000l)),
631     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0x433FFFFFFFFFFFFFl)),
634     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0x4340000000000000l)),
637     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0x43DFFFFFFFFFFFFFl)),
640     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0x43E0000000000000l)),
643     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0x43F0000000000000l)),
646     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0xC32FFFFFFFFFFFFDl)),
649     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0xC32FFFFFFFFFFFFFl)),
652     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0xC330000000000000l)),
655     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0xC33FFFFFFFFFFFFFl)),
658     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0xC340000000000000l)),
661     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0xC3DFFFFFFFFFFFFFl)),
664     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0xC3E0000000000000l)),
667     Assert.assertEquals(Math.ceil(Double.longBitsToDouble(0xC3F0000000000000l)),
669     Assert.assertEquals(Math.ceil(Double.NaN), Double.NaN, 0.0);
670     Assert.assertEquals(Math.ceil(Double.POSITIVE_INFINITY), Double.POSITIVE_INFINITY, 0.0);
671     Assert.assertEquals(Math.ceil(Double.NEGATIVE_INFINITY), Double.NEGATIVE_INFINITY, 0.0);
676     Assert.assertEquals(Math.floor(+0.0), +0.0d, 0.0);
677     Assert.assertEquals(Math.floor(-0.0), -0.0d, 0.0);
678     Assert.assertEquals(Math.floor(+2.0), +2.0d, 0.0);
679     Assert.assertEquals(Math.floor(+2.1), +2.0d, 0.0);
680     Assert.assertEquals(Math.floor(+2.5), +2.0d, 0.0);
681     Assert.assertEquals(Math.floor(+2.9), +2.0d, 0.0);
682     Assert.assertEquals(Math.floor(+3.0), +3.0d, 0.0);
683     Assert.assertEquals(Math.floor(-2.0), -2.0d, 0.0);
684     Assert.assertEquals(Math.floor(-2.1), -3.0d, 0.0);
685     Assert.assertEquals(Math.floor(-2.5), -3.0d, 0.0);
686     Assert.assertEquals(Math.floor(-2.9), -3.0d, 0.0);
687     Assert.assertEquals(Math.floor(-3.0), -3.0d, 0.0);
689     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0x432FFFFFFFFFFFFDl)),
692     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0x432FFFFFFFFFFFFFl)),
695     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0x4330000000000000l)),
698     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0x433FFFFFFFFFFFFFl)),
701     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0x4340000000000000l)),
704     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0x43DFFFFFFFFFFFFFl)),
707     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0x43E0000000000000l)),
710     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0x43F0000000000000l)),
713     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0xC32FFFFFFFFFFFFDl)),
716     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0xC32FFFFFFFFFFFFFl)),
719     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0xC330000000000000l)),
722     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0xC33FFFFFFFFFFFFFl)),
725     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0xC340000000000000l)),
728     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0xC3DFFFFFFFFFFFFFl)),
731     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0xC3E0000000000000l)),
734     Assert.assertEquals(Math.floor(Double.longBitsToDouble(0xC3F0000000000000l)),
736     Assert.assertEquals(Math.floor(Double.NaN), Double.NaN, 0.0);
737     Assert.assertEquals(Math.floor(Double.POSITIVE_INFINITY), Double.POSITIVE_INFINITY, 0.0);
738     Assert.assertEquals(Math.floor(Double.NEGATIVE_INFINITY), Double.NEGATIVE_INFINITY, 0.0);
743     Assert.assertEquals(Math.rint(+0.0), +0.0d, 0.0);
744     Assert.assertEquals(Math.rint(-0.0), -0.0d, 0.0);
745     Assert.assertEquals(Math.rint(+0.5), +0.0d, 0.0);  // expects tie-to-even
746     Assert.assertEquals(Math.rint(+2.0), +2.0d, 0.0);
747     Assert.assertEquals(Math.rint(+2.1), +2.0d, 0.0);
748     Assert.assertEquals(Math.rint(+2.5), +2.0d, 0.0);  // expects tie-to-even
749     Assert.assertEquals(Math.rint(+2.9), +3.0d, 0.0);
750     Assert.assertEquals(Math.rint(+3.0), +3.0d, 0.0);
751     Assert.assertEquals(Math.rint(+3.5), +4.0d, 0.0);  // expects tie-to-even
752     Assert.assertEquals(Math.rint(-2.0), -2.0d, 0.0);
753     Assert.assertEquals(Math.rint(-2.1), -2.0d, 0.0);
754     Assert.assertEquals(Math.rint(-2.5), -2.0d, 0.0);  // expects tie-to-even
755     Assert.assertEquals(Math.rint(-2.9), -3.0d, 0.0);
756     Assert.assertEquals(Math.rint(-3.0), -3.0d, 0.0);
757     Assert.assertEquals(Math.rint(-3.5), -4.0d, 0.0);  // expects tie-to-even
759     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0x432FFFFFFFFFFFFDl)),
762     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0x432FFFFFFFFFFFFFl)),
765     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0x4330000000000000l)),
768     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0x433FFFFFFFFFFFFFl)),
771     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0x4340000000000000l)),
774     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0x43DFFFFFFFFFFFFFl)),
777     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0x43E0000000000000l)),
780     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0x43F0000000000000l)),
783     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0xC32FFFFFFFFFFFFDl)),
786     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0xC32FFFFFFFFFFFFFl)),
789     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0xC330000000000000l)),
792     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0xC33FFFFFFFFFFFFFl)),
795     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0xC340000000000000l)),
798     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0xC3DFFFFFFFFFFFFFl)),
801     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0xC3E0000000000000l)),
804     Assert.assertEquals(Math.rint(Double.longBitsToDouble(0xC3F0000000000000l)),
806     Assert.assertEquals(Math.rint(Double.NaN), Double.NaN, 0.0);
807     Assert.assertEquals(Math.rint(Double.POSITIVE_INFINITY), Double.POSITIVE_INFINITY, 0.0);
808     Assert.assertEquals(Math.rint(Double.NEGATIVE_INFINITY), Double.NEGATIVE_INFINITY, 0.0);
813     Assert.assertEquals(Math.round(+0.0d), (long)+0.0);
814     Assert.assertEquals(Math.round(-0.0d), (long)+0.0);
815     Assert.assertEquals(Math.round(2.0d), 2l);
816     Assert.assertEquals(Math.round(2.1d), 2l);
817     Assert.assertEquals(Math.round(2.5d), 3l);
818     Assert.assertEquals(Math.round(2.9d), 3l);
819     Assert.assertEquals(Math.round(3.0d), 3l);
820     Assert.assertEquals(Math.round(-2.0d), -2l);
821     Assert.assertEquals(Math.round(-2.1d), -2l);
822     Assert.assertEquals(Math.round(-2.5d), -2l);
823     Assert.assertEquals(Math.round(-2.9d), -3l);
824     Assert.assertEquals(Math.round(-3.0d), -3l);
825     Assert.assertEquals(Math.round(0.49999999999999994d), 0l);
826     Assert.assertEquals(Math.round(4503599627370495.0d), 4503599627370495l);  // 2^52 - 1
827     Assert.assertEquals(Math.round(4503599627370495.5d), 4503599627370496l);  // 2^52 - 0.5
828     Assert.assertEquals(Math.round(4503599627370496.0d), 4503599627370496l);  // 2^52
829     Assert.assertEquals(Math.round(-4503599627370495.0d), -4503599627370495l);  // -(2^52 - 1)
830     Assert.assertEquals(Math.round(-4503599627370495.5d), -4503599627370495l);  // -(2^52 - 0.5)
831     Assert.assertEquals(Math.round(-4503599627370496.0d), -4503599627370496l);  // -2^52
832     Assert.assertEquals(Math.round(9007199254740991.0d), 9007199254740991l);  // 2^53 - 1
833     Assert.assertEquals(Math.round(-9007199254740991.0d), -9007199254740991l);  // -(2^53 - 1)
834     Assert.assertEquals(Math.round(Double.NaN), (long)+0.0d);
835     Assert.assertEquals(Math.round(Long.MAX_VALUE + 1.0d), Long.MAX_VALUE);
836     Assert.assertEquals(Math.round(Long.MIN_VALUE - 1.0d), Long.MIN_VALUE);
837     Assert.assertEquals(Math.round(Double.longBitsToDouble(0x43F0000000000000l)),
839     Assert.assertEquals(Math.round(Double.longBitsToDouble(0xC3F0000000000000l)),
841     Assert.assertEquals(Math.round(Double.POSITIVE_INFINITY), Long.MAX_VALUE);
842     Assert.assertEquals(Math.round(Double.NEGATIVE_INFINITY), Long.MIN_VALUE);
847     Assert.assertEquals(Math.round(+0.0f), (int)+0.0);
848     Assert.assertEquals(Math.round(-0.0f), (int)+0.0);
849     Assert.assertEquals(Math.round(2.0f), 2);
850     Assert.assertEquals(Math.round(2.1f), 2);
851     Assert.assertEquals(Math.round(2.5f), 3);
852     Assert.assertEquals(Math.round(2.9f), 3);
853     Assert.assertEquals(Math.round(3.0f), 3);
854     Assert.assertEquals(Math.round(-2.0f), -2);
855     Assert.assertEquals(Math.round(-2.1f), -2);
856     Assert.assertEquals(Math.round(-2.5f), -2);
857     Assert.assertEquals(Math.round(-2.9f), -3);
858     Assert.assertEquals(Math.round(-3.0f), -3);
860     Assert.assertEquals(Math.round(Float.intBitsToFloat(0x3EFFFFFF)), (int)+0.0f);
861     Assert.assertEquals(Math.round(8388607.0f), 8388607);  // 2^23 - 1
862     Assert.assertEquals(Math.round(8388607.5f), 8388608);  // 2^23 - 0.5
863     Assert.assertEquals(Math.round(8388608.0f), 8388608);  // 2^23
864     Assert.assertEquals(Math.round(-8388607.0f), -8388607);  // -(2^23 - 1)
865     Assert.assertEquals(Math.round(-8388607.5f), -8388607);  // -(2^23 - 0.5)
866     Assert.assertEquals(Math.round(-8388608.0f), -8388608);  // -2^23
867     Assert.assertEquals(Math.round(16777215.0f), 16777215);  // 2^24 - 1
868     Assert.assertEquals(Math.round(16777216.0f), 16777216);  // 2^24
869     Assert.assertEquals(Math.round(-16777215.0f), -16777215);  // -(2^24 - 1)
870     Assert.assertEquals(Math.round(-16777216.0f), -16777216);  // -2^24
871     Assert.assertEquals(Math.round(Float.NaN), (int)+0.0f);
872     Assert.assertEquals(Math.round(Integer.MAX_VALUE + 1.0f), Integer.MAX_VALUE);
873     Assert.assertEquals(Math.round(Integer.MIN_VALUE - 1.0f), Integer.MIN_VALUE);
874     Assert.assertEquals(Math.round(Float.intBitsToFloat(0x4F800000)),
876     Assert.assertEquals(Math.round(Float.intBitsToFloat(0xCF800000)),
878     Assert.assertEquals(Math.round(Float.POSITIVE_INFINITY), Integer.MAX_VALUE);
879     Assert.assertEquals(Math.round(Float.NEGATIVE_INFINITY), Integer.MIN_VALUE);
984     Assert.assertEquals(Math.multiplyHigh(2L, 3L), 0L);
985     Assert.assertEquals(Math.multiplyHigh(Long.MAX_VALUE, Long.MAX_VALUE), 4611686018427387903L);
990     Assert.assertEquals(StrictMath.abs(0), 0);
991     Assert.assertEquals(StrictMath.abs(123), 123);
992     Assert.assertEquals(StrictMath.abs(-123), 123);
993     Assert.assertEquals(StrictMath.abs(Integer.MAX_VALUE), Integer.MAX_VALUE);
994     Assert.assertEquals(StrictMath.abs(Integer.MIN_VALUE), Integer.MIN_VALUE);
995     Assert.assertEquals(StrictMath.abs(Integer.MIN_VALUE - 1), Integer.MAX_VALUE);
996     Assert.assertEquals(StrictMath.abs(Integer.MIN_VALUE + 1), Integer.MAX_VALUE);
1001     Assert.assertEquals(StrictMath.abs(0L), 0L);
1002     Assert.assertEquals(StrictMath.abs(123L), 123L);
1003     Assert.assertEquals(StrictMath.abs(-123L), 123L);
1004     Assert.assertEquals(StrictMath.abs(Long.MAX_VALUE), Long.MAX_VALUE);
1005     Assert.assertEquals(StrictMath.abs(Long.MIN_VALUE), Long.MIN_VALUE);
1006     Assert.assertEquals(StrictMath.abs(Long.MIN_VALUE - 1), Long.MAX_VALUE);
1011     Assert.assertEquals(StrictMath.min(0, 0), 0);
1012     Assert.assertEquals(StrictMath.min(1, 0), 0);
1013     Assert.assertEquals(StrictMath.min(0, 1), 0);
1014     Assert.assertEquals(StrictMath.min(0, Integer.MAX_VALUE), 0);
1015     Assert.assertEquals(StrictMath.min(Integer.MIN_VALUE, 0), Integer.MIN_VALUE);
1016     Assert.assertEquals(StrictMath.min(Integer.MIN_VALUE, Integer.MAX_VALUE), Integer.MIN_VALUE);
1021     Assert.assertEquals(StrictMath.max(0, 0), 0);
1022     Assert.assertEquals(StrictMath.max(1, 0), 1);
1023     Assert.assertEquals(StrictMath.max(0, 1), 1);
1024     Assert.assertEquals(StrictMath.max(0, Integer.MAX_VALUE), Integer.MAX_VALUE);
1025     Assert.assertEquals(StrictMath.max(Integer.MIN_VALUE, 0), 0);
1026     Assert.assertEquals(StrictMath.max(Integer.MIN_VALUE, Integer.MAX_VALUE), Integer.MAX_VALUE);
1031     Assert.assertEquals(StrictMath.min(0L, 0L), 0L);
1032     Assert.assertEquals(StrictMath.min(1L, 0L), 0L);
1033     Assert.assertEquals(StrictMath.min(0L, 1L), 0L);
1034     Assert.assertEquals(StrictMath.min(0L, Long.MAX_VALUE), 0L);
1035     Assert.assertEquals(StrictMath.min(Long.MIN_VALUE, 0L), Long.MIN_VALUE);
1036     Assert.assertEquals(StrictMath.min(Long.MIN_VALUE, Long.MAX_VALUE), Long.MIN_VALUE);
1041     Assert.assertEquals(StrictMath.max(0L, 0L), 0L);
1042     Assert.assertEquals(StrictMath.max(1L, 0L), 1L);
1043     Assert.assertEquals(StrictMath.max(0L, 1L), 1L);
1044     Assert.assertEquals(StrictMath.max(0L, Long.MAX_VALUE), Long.MAX_VALUE);
1045     Assert.assertEquals(StrictMath.max(Long.MIN_VALUE, 0L), 0L);
1046     Assert.assertEquals(StrictMath.max(Long.MIN_VALUE, Long.MAX_VALUE), Long.MAX_VALUE);
1053     Assert.assertEquals(StrictMath.min(-0.0f, 0.0f), -0.0f);
1054     Assert.assertEquals(StrictMath.min(0.0f, -0.0f), -0.0f);
1055     Assert.assertEquals(StrictMath.min(-0.0f, -0.0f), -0.0f);
1056     Assert.assertEquals(StrictMath.min(0.0f, 0.0f), 0.0f);
1057     Assert.assertEquals(StrictMath.min(1.0f, 0.0f), 0.0f);
1058     Assert.assertEquals(StrictMath.min(0.0f, 1.0f), 0.0f);
1059     Assert.assertEquals(StrictMath.min(0.0f, Float.MAX_VALUE), 0.0f);
1060     Assert.assertEquals(StrictMath.min(Float.MIN_VALUE, 0.0f), 0.0f);
1061     Assert.assertEquals(StrictMath.min(Float.MIN_VALUE, Float.MAX_VALUE), Float.MIN_VALUE);
1068     Assert.assertEquals(StrictMath.max(-0.0f, 0.0f), 0.0f);
1069     Assert.assertEquals(StrictMath.max(0.0f, -0.0f), 0.0f);
1070     Assert.assertEquals(StrictMath.max(-0.0f, -0.0f), -0.0f);
1071     Assert.assertEquals(StrictMath.max(0.0f, 0.0f), 0.0f);
1072     Assert.assertEquals(StrictMath.max(1.0f, 0.0f), 1.0f);
1073     Assert.assertEquals(StrictMath.max(0.0f, 1.0f), 1.0f);
1074     Assert.assertEquals(StrictMath.max(0.0f, Float.MAX_VALUE), Float.MAX_VALUE);
1075     Assert.assertEquals(StrictMath.max(Float.MIN_VALUE, 0.0f), Float.MIN_VALUE);
1076     Assert.assertEquals(StrictMath.max(Float.MIN_VALUE, Float.MAX_VALUE), Float.MAX_VALUE);
1083     Assert.assertEquals(StrictMath.min(-0.0d, 0.0d), -0.0d);
1084     Assert.assertEquals(StrictMath.min(0.0d, -0.0d), -0.0d);
1085     Assert.assertEquals(StrictMath.min(-0.0d, -0.0d), -0.0d);
1086     Assert.assertEquals(StrictMath.min(0.0d, 0.0d), 0.0d);
1087     Assert.assertEquals(StrictMath.min(1.0d, 0.0d), 0.0d);
1088     Assert.assertEquals(StrictMath.min(0.0d, 1.0d), 0.0d);
1089     Assert.assertEquals(StrictMath.min(0.0d, Double.MAX_VALUE), 0.0d);
1090     Assert.assertEquals(StrictMath.min(Double.MIN_VALUE, 0.0d), 0.0d);
1091     Assert.assertEquals(StrictMath.min(Double.MIN_VALUE, Double.MAX_VALUE), Double.MIN_VALUE);
1098     Assert.assertEquals(StrictMath.max(-0.0d, 0.0d), 0.0d);
1099     Assert.assertEquals(StrictMath.max(0.0d, -0.0d), 0.0d);
1100     Assert.assertEquals(StrictMath.max(-0.0d, -0.0d), -0.0d);
1101     Assert.assertEquals(StrictMath.max(0.0d, 0.0d), 0.0d);
1102     Assert.assertEquals(StrictMath.max(1.0d, 0.0d), 1.0d);
1103     Assert.assertEquals(StrictMath.max(0.0d, 1.0d), 1.0d);
1104     Assert.assertEquals(StrictMath.max(0.0d, Double.MAX_VALUE), Double.MAX_VALUE);
1105     Assert.assertEquals(StrictMath.max(Double.MIN_VALUE, 0.0d), Double.MIN_VALUE);
1106     Assert.assertEquals(StrictMath.max(Double.MIN_VALUE, Double.MAX_VALUE), Double.MAX_VALUE);
1111     Assert.assertEquals(StrictMath.sqrt(+4.0), +2.0d, 0.0);
1112     Assert.assertEquals(StrictMath.sqrt(+49.0), +7.0d, 0.0);
1113     Assert.assertEquals(StrictMath.sqrt(+1.44), +1.2d, 0.0);
1118     Assert.assertEquals(StrictMath.ceil(+0.0), +0.0d, 0.0);
1119     Assert.assertEquals(StrictMath.ceil(-0.0), -0.0d, 0.0);
1120     Assert.assertEquals(StrictMath.ceil(-0.9), -0.0d, 0.0);
1121     Assert.assertEquals(StrictMath.ceil(-0.5), -0.0d, 0.0);
1122     Assert.assertEquals(StrictMath.ceil(0.0), -0.0d, 0.0);
1123     Assert.assertEquals(StrictMath.ceil(+2.0), +2.0d, 0.0);
1124     Assert.assertEquals(StrictMath.ceil(+2.1), +3.0d, 0.0);
1125     Assert.assertEquals(StrictMath.ceil(+2.5), +3.0d, 0.0);
1126     Assert.assertEquals(StrictMath.ceil(+2.9), +3.0d, 0.0);
1127     Assert.assertEquals(StrictMath.ceil(+3.0), +3.0d, 0.0);
1128     Assert.assertEquals(StrictMath.ceil(-2.0), -2.0d, 0.0);
1129     Assert.assertEquals(StrictMath.ceil(-2.1), -2.0d, 0.0);
1130     Assert.assertEquals(StrictMath.ceil(-2.5), -2.0d, 0.0);
1131     Assert.assertEquals(StrictMath.ceil(-2.9), -2.0d, 0.0);
1132     Assert.assertEquals(StrictMath.ceil(-3.0), -3.0d, 0.0);
1133     Assert.assertEquals(StrictMath.ceil(Double.NaN), Double.NaN, 0.0);
1134     Assert.assertEquals(StrictMath.ceil(Double.POSITIVE_INFINITY), Double.POSITIVE_INFINITY, 0.0);
1135     Assert.assertEquals(StrictMath.ceil(Double.NEGATIVE_INFINITY), Double.NEGATIVE_INFINITY, 0.0);
1140     Assert.assertEquals(StrictMath.floor(+0.0), +0.0d, 0.0);
1141     Assert.assertEquals(StrictMath.floor(-0.0), -0.0d, 0.0);
1142     Assert.assertEquals(StrictMath.floor(+2.0), +2.0d, 0.0);
1143     Assert.assertEquals(StrictMath.floor(+2.1), +2.0d, 0.0);
1144     Assert.assertEquals(StrictMath.floor(+2.5), +2.0d, 0.0);
1145     Assert.assertEquals(StrictMath.floor(+2.9), +2.0d, 0.0);
1146     Assert.assertEquals(StrictMath.floor(+3.0), +3.0d, 0.0);
1147     Assert.assertEquals(StrictMath.floor(-2.0), -2.0d, 0.0);
1148     Assert.assertEquals(StrictMath.floor(-2.1), -3.0d, 0.0);
1149     Assert.assertEquals(StrictMath.floor(-2.5), -3.0d, 0.0);
1150     Assert.assertEquals(StrictMath.floor(-2.9), -3.0d, 0.0);
1151     Assert.assertEquals(StrictMath.floor(-3.0), -3.0d, 0.0);
1152     Assert.assertEquals(StrictMath.floor(Double.NaN), Double.NaN, 0.0);
1153     Assert.assertEquals(StrictMath.floor(Double.POSITIVE_INFINITY), Double.POSITIVE_INFINITY, 0.0);
1154     Assert.assertEquals(StrictMath.floor(Double.NEGATIVE_INFINITY), Double.NEGATIVE_INFINITY, 0.0);
1159     Assert.assertEquals(StrictMath.rint(+0.0), +0.0d, 0.0);
1160     Assert.assertEquals(StrictMath.rint(-0.0), -0.0d, 0.0);
1161     Assert.assertEquals(StrictMath.rint(+2.0), +2.0d, 0.0);
1162     Assert.assertEquals(StrictMath.rint(+2.1), +2.0d, 0.0);
1163     Assert.assertEquals(StrictMath.rint(+2.5), +2.0d, 0.0);
1164     Assert.assertEquals(StrictMath.rint(+2.9), +3.0d, 0.0);
1165     Assert.assertEquals(StrictMath.rint(+3.0), +3.0d, 0.0);
1166     Assert.assertEquals(StrictMath.rint(-2.0), -2.0d, 0.0);
1167     Assert.assertEquals(StrictMath.rint(-2.1), -2.0d, 0.0);
1168     Assert.assertEquals(StrictMath.rint(-2.5), -2.0d, 0.0);
1169     Assert.assertEquals(StrictMath.rint(-2.9), -3.0d, 0.0);
1170     Assert.assertEquals(StrictMath.rint(-3.0), -3.0d, 0.0);
1171     Assert.assertEquals(StrictMath.rint(Double.NaN), Double.NaN, 0.0);
1172     Assert.assertEquals(StrictMath.rint(Double.POSITIVE_INFINITY), Double.POSITIVE_INFINITY, 0.0);
1173     Assert.assertEquals(StrictMath.rint(Double.NEGATIVE_INFINITY), Double.NEGATIVE_INFINITY, 0.0);
1178     Assert.assertEquals(StrictMath.round(+0.0d), (long)+0.0);
1179     Assert.assertEquals(StrictMath.round(-0.0d), (long)+0.0);
1180     Assert.assertEquals(StrictMath.round(2.0d), 2l);
1181     Assert.assertEquals(StrictMath.round(2.1d), 2l);
1182     Assert.assertEquals(StrictMath.round(2.5d), 3l);
1183     Assert.assertEquals(StrictMath.round(2.9d), 3l);
1184     Assert.assertEquals(StrictMath.round(3.0d), 3l);
1185     Assert.assertEquals(StrictMath.round(-2.0d), -2l);
1186     Assert.assertEquals(StrictMath.round(-2.1d), -2l);
1187     Assert.assertEquals(StrictMath.round(-2.5d), -2l);
1188     Assert.assertEquals(StrictMath.round(-2.9d), -3l);
1189     Assert.assertEquals(StrictMath.round(-3.0d), -3l);
1190     Assert.assertEquals(StrictMath.round(0.49999999999999994d), 0l);
1191     Assert.assertEquals(StrictMath.round(4503599627370495.0d), 4503599627370495l);  // 2^52 - 1
1192     Assert.assertEquals(StrictMath.round(4503599627370495.5d), 4503599627370496l);  // 2^52 - 0.5
1193     Assert.assertEquals(StrictMath.round(4503599627370496.0d), 4503599627370496l);  // 2^52
1194     Assert.assertEquals(StrictMath.round(-4503599627370495.0d), -4503599627370495l);  // -(2^52 - 1)
1195 … Assert.assertEquals(StrictMath.round(-4503599627370495.5d), -4503599627370495l);  // -(2^52 - 0.5)
1196     Assert.assertEquals(StrictMath.round(-4503599627370496.0d), -4503599627370496l);  // -2^52
1197     Assert.assertEquals(StrictMath.round(9007199254740991.0d), 9007199254740991l);  // 2^53 - 1
1198     Assert.assertEquals(StrictMath.round(-9007199254740991.0d), -9007199254740991l);  // -(2^53 - 1)
1199     Assert.assertEquals(StrictMath.round(Double.NaN), (long)+0.0d);
1200     Assert.assertEquals(StrictMath.round(Long.MAX_VALUE + 1.0d), Long.MAX_VALUE);
1201     Assert.assertEquals(StrictMath.round(Long.MIN_VALUE - 1.0d), Long.MIN_VALUE);
1202     Assert.assertEquals(StrictMath.round(Double.longBitsToDouble(0x43F0000000000000l)),
1204     Assert.assertEquals(StrictMath.round(Double.longBitsToDouble(0xC3F0000000000000l)),
1206     Assert.assertEquals(StrictMath.round(Double.POSITIVE_INFINITY), Long.MAX_VALUE);
1207     Assert.assertEquals(StrictMath.round(Double.NEGATIVE_INFINITY), Long.MIN_VALUE);
1212     Assert.assertEquals(StrictMath.round(+0.0f), (int)+0.0);
1213     Assert.assertEquals(StrictMath.round(-0.0f), (int)+0.0);
1214     Assert.assertEquals(StrictMath.round(2.0f), 2);
1215     Assert.assertEquals(StrictMath.round(2.1f), 2);
1216     Assert.assertEquals(StrictMath.round(2.5f), 3);
1217     Assert.assertEquals(StrictMath.round(2.9f), 3);
1218     Assert.assertEquals(StrictMath.round(3.0f), 3);
1219     Assert.assertEquals(StrictMath.round(-2.0f), -2);
1220     Assert.assertEquals(StrictMath.round(-2.1f), -2);
1221     Assert.assertEquals(StrictMath.round(-2.5f), -2);
1222     Assert.assertEquals(StrictMath.round(-2.9f), -3);
1223     Assert.assertEquals(StrictMath.round(-3.0f), -3);
1225     Assert.assertEquals(StrictMath.round(Float.intBitsToFloat(0x3EFFFFFF)), (int)+0.0f);
1226     Assert.assertEquals(StrictMath.round(8388607.0f), 8388607);  // 2^23 - 1
1227     Assert.assertEquals(StrictMath.round(8388607.5f), 8388608);  // 2^23 - 0.5
1228     Assert.assertEquals(StrictMath.round(8388608.0f), 8388608);  // 2^23
1229     Assert.assertEquals(StrictMath.round(-8388607.0f), -8388607);  // -(2^23 - 1)
1230     Assert.assertEquals(StrictMath.round(-8388607.5f), -8388607);  // -(2^23 - 0.5)
1231     Assert.assertEquals(StrictMath.round(-8388608.0f), -8388608);  // -2^23
1232     Assert.assertEquals(StrictMath.round(16777215.0f), 16777215);  // 2^24 - 1
1233     Assert.assertEquals(StrictMath.round(16777216.0f), 16777216);  // 2^24
1234     Assert.assertEquals(StrictMath.round(-16777215.0f), -16777215);  // -(2^24 - 1)
1235     Assert.assertEquals(StrictMath.round(-16777216.0f), -16777216);  // -2^24
1236     Assert.assertEquals(StrictMath.round(Float.NaN), (int)+0.0f);
1237     Assert.assertEquals(StrictMath.round(Integer.MAX_VALUE + 1.0f), Integer.MAX_VALUE);
1238     Assert.assertEquals(StrictMath.round(Integer.MIN_VALUE - 1.0f), Integer.MIN_VALUE);
1239     Assert.assertEquals(StrictMath.round(Float.intBitsToFloat(0x4F800000)),
1241     Assert.assertEquals(StrictMath.round(Float.intBitsToFloat(0xCF800000)),
1243     Assert.assertEquals(StrictMath.round(Float.POSITIVE_INFINITY), Integer.MAX_VALUE);
1244     Assert.assertEquals(StrictMath.round(Float.NEGATIVE_INFINITY), Integer.MIN_VALUE);
1249     Assert.assertEquals(Float.floatToRawIntBits(-1.0f), 0xbf800000);
1250     Assert.assertEquals(Float.floatToRawIntBits(0.0f), 0);
1251     Assert.assertEquals(Float.floatToRawIntBits(1.0f), 0x3f800000);
1252     Assert.assertEquals(Float.floatToRawIntBits(Float.NaN), 0x7fc00000);
1253     Assert.assertEquals(Float.floatToRawIntBits(Float.POSITIVE_INFINITY), 0x7f800000);
1254     Assert.assertEquals(Float.floatToRawIntBits(Float.NEGATIVE_INFINITY), 0xff800000);
1259     Assert.assertEquals(Float.intBitsToFloat(0xbf800000), -1.0f);
1260     Assert.assertEquals(Float.intBitsToFloat(0x00000000), 0.0f);
1261     Assert.assertEquals(Float.intBitsToFloat(0x3f800000), 1.0f);
1262     Assert.assertEquals(Float.intBitsToFloat(0x7fc00000), Float.NaN);
1263     Assert.assertEquals(Float.intBitsToFloat(0x7f800000), Float.POSITIVE_INFINITY);
1264     Assert.assertEquals(Float.intBitsToFloat(0xff800000), Float.NEGATIVE_INFINITY);
1269     Assert.assertEquals(Double.doubleToRawLongBits(-1.0), 0xbff0000000000000L);
1270     Assert.assertEquals(Double.doubleToRawLongBits(0.0), 0x0000000000000000L);
1271     Assert.assertEquals(Double.doubleToRawLongBits(1.0), 0x3ff0000000000000L);
1272     Assert.assertEquals(Double.doubleToRawLongBits(Double.NaN), 0x7ff8000000000000L);
1273     Assert.assertEquals(Double.doubleToRawLongBits(Double.POSITIVE_INFINITY), 0x7ff0000000000000L);
1274     Assert.assertEquals(Double.doubleToRawLongBits(Double.NEGATIVE_INFINITY), 0xfff0000000000000L);
1279     Assert.assertEquals(Double.longBitsToDouble(0xbff0000000000000L), -1.0);
1280     Assert.assertEquals(Double.longBitsToDouble(0x0000000000000000L), 0.0);
1281     Assert.assertEquals(Double.longBitsToDouble(0x3ff0000000000000L), 1.0);
1282     Assert.assertEquals(Double.longBitsToDouble(0x7ff8000000000000L), Double.NaN);
1283     Assert.assertEquals(Double.longBitsToDouble(0x7ff0000000000000L), Double.POSITIVE_INFINITY);
1284     Assert.assertEquals(Double.longBitsToDouble(0xfff0000000000000L), Double.NEGATIVE_INFINITY);
1289       Assert.assertEquals(Short.reverseBytes((short)0x0000), (short)0x0000);
1290       Assert.assertEquals(Short.reverseBytes((short)0xffff), (short)0xffff);
1291       Assert.assertEquals(Short.reverseBytes((short)0x8000), (short)0x0080);
1292       Assert.assertEquals(Short.reverseBytes((short)0x0080), (short)0x8000);
1293       Assert.assertEquals(Short.reverseBytes((short)0x0123), (short)0x2301);
1294       Assert.assertEquals(Short.reverseBytes((short)0x4567), (short)0x6745);
1295       Assert.assertEquals(Short.reverseBytes((short)0x89ab), (short)0xab89);
1296       Assert.assertEquals(Short.reverseBytes((short)0xcdef), (short)0xefcd);
1301       Assert.assertEquals(Integer.reverseBytes(0x00000000), 0x00000000);
1302       Assert.assertEquals(Integer.reverseBytes(0xffffffff), 0xffffffff);
1303       Assert.assertEquals(Integer.reverseBytes(0x80000000), 0x00000080);
1304       Assert.assertEquals(Integer.reverseBytes(0x00000080), 0x80000000);
1305       Assert.assertEquals(Integer.reverseBytes(0x01234567), 0x67452301);
1306       Assert.assertEquals(Integer.reverseBytes(0x89abcdef), 0xefcdab89);
1311       Assert.assertEquals(Long.reverseBytes(0x0000000000000000L), 0x0000000000000000L);
1312       Assert.assertEquals(Long.reverseBytes(0xffffffffffffffffL), 0xffffffffffffffffL);
1313       Assert.assertEquals(Long.reverseBytes(0x8000000000000000L), 0x0000000000000080L);
1314       Assert.assertEquals(Long.reverseBytes(0x0000000000000080L), 0x8000000000000000L);
1315       Assert.assertEquals(Long.reverseBytes(0x0123456789abcdefL), 0xefcdab8967452301L);
1320     Assert.assertEquals(Integer.reverse(1), 0x80000000);
1321     Assert.assertEquals(Integer.reverse(-1), 0xffffffff);
1322     Assert.assertEquals(Integer.reverse(0), 0);
1323     Assert.assertEquals(Integer.reverse(0x12345678), 0x1e6a2c48);
1324     Assert.assertEquals(Integer.reverse(0x87654321), 0x84c2a6e1);
1325     Assert.assertEquals(Integer.reverse(Integer.MAX_VALUE), 0xfffffffe);
1326     Assert.assertEquals(Integer.reverse(Integer.MIN_VALUE), 1);
1331     Assert.assertEquals(Long.reverse(1L), 0x8000000000000000L);
1332     Assert.assertEquals(Long.reverse(-1L), 0xffffffffffffffffL);
1333     Assert.assertEquals(Long.reverse(0L), 0L);
1334     Assert.assertEquals(Long.reverse(0x1234567812345678L), 0x1e6a2c481e6a2c48L);
1335     Assert.assertEquals(Long.reverse(0x8765432187654321L), 0x84c2a6e184c2a6e1L);
1336     Assert.assertEquals(Long.reverse(Long.MAX_VALUE), 0xfffffffffffffffeL);
1337     Assert.assertEquals(Long.reverse(Long.MIN_VALUE), 1L);
1339     Assert.assertEquals(test_Long_reverse_b22324327(0xaaaaaaaaaaaaaaaaL, 0x5555555555555555L),
1389     Assert.assertEquals(Integer.divideUnsigned(100, 10), 10);
1390     Assert.assertEquals(Integer.divideUnsigned(100, 1), 100);
1391     Assert.assertEquals(Integer.divideUnsigned(1024, 128), 8);
1392     Assert.assertEquals(Integer.divideUnsigned(12345678, 264), 46763);
1393     Assert.assertEquals(Integer.divideUnsigned(13, 5), 2);
1394     Assert.assertEquals(Integer.divideUnsigned(-2, 2), Integer.MAX_VALUE);
1395     Assert.assertEquals(Integer.divideUnsigned(-1, 2), Integer.MAX_VALUE);
1396     Assert.assertEquals(Integer.divideUnsigned(100000, -1), 0);
1397     Assert.assertEquals(Integer.divideUnsigned(Integer.MAX_VALUE, -1), 0);
1398     Assert.assertEquals(Integer.divideUnsigned(-2, -1), 0);
1399     Assert.assertEquals(Integer.divideUnsigned(-1, -2), 1);
1400     Assert.assertEquals(Integer.divideUnsigned(-173448, 13), 330368757);
1401     Assert.assertEquals(Integer.divideUnsigned(Integer.MIN_VALUE, 2), (1 << 30));
1402     Assert.assertEquals(Integer.divideUnsigned(-1, Integer.MIN_VALUE), 1);
1403     Assert.assertEquals(Integer.divideUnsigned(Integer.MAX_VALUE, Integer.MIN_VALUE), 0);
1404     Assert.assertEquals(Integer.divideUnsigned(Integer.MIN_VALUE, Integer.MAX_VALUE), 1);
1417     Assert.assertEquals(Long.divideUnsigned(100L, 10L), 10L);
1418     Assert.assertEquals(Long.divideUnsigned(100L, 1L), 100L);
1419     Assert.assertEquals(Long.divideUnsigned(1024L, 128L), 8L);
1420     Assert.assertEquals(Long.divideUnsigned(12345678L, 264L), 46763L);
1421     Assert.assertEquals(Long.divideUnsigned(13L, 5L), 2L);
1422     Assert.assertEquals(Long.divideUnsigned(-2L, 2L), Long.MAX_VALUE);
1423     Assert.assertEquals(Long.divideUnsigned(-1L, 2L), Long.MAX_VALUE);
1424     Assert.assertEquals(Long.divideUnsigned(100000L, -1L), 0L);
1425     Assert.assertEquals(Long.divideUnsigned(Long.MAX_VALUE, -1L), 0L);
1426     Assert.assertEquals(Long.divideUnsigned(-2L, -1L), 0L);
1427     Assert.assertEquals(Long.divideUnsigned(-1L, -2L), 1L);
1428     Assert.assertEquals(Long.divideUnsigned(-173448L, 13L), 1418980313362259859L);
1429     Assert.assertEquals(Long.divideUnsigned(Long.MIN_VALUE, 2L), (1L << 62));
1430     Assert.assertEquals(Long.divideUnsigned(-1L, Long.MIN_VALUE), 1L);
1431     Assert.assertEquals(Long.divideUnsigned(Long.MAX_VALUE, Long.MIN_VALUE), 0L);
1432     Assert.assertEquals(Long.divideUnsigned(Long.MIN_VALUE, Long.MAX_VALUE), 1L);
1433     Assert.assertEquals(Long.divideUnsigned(Long.MAX_VALUE, 1L), Long.MAX_VALUE);
1434     Assert.assertEquals(Long.divideUnsigned(Long.MIN_VALUE, 1L), Long.MIN_VALUE);
1435     Assert.assertEquals(Long.divideUnsigned(BIG_LONG_VALUE, BIG_LONG_VALUE), 1L);
1436     Assert.assertEquals(Long.divideUnsigned(BIG_LONG_VALUE, 1L), BIG_LONG_VALUE);
1437     Assert.assertEquals(Long.divideUnsigned(BIG_LONG_VALUE, 1024L), 721960566564885L);
1438     Assert.assertEquals(Long.divideUnsigned(BIG_LONG_VALUE, 0x1FFFFFFFFL), 86064406L);
1448     Assert.assertEquals(Integer.numberOfLeadingZeros(0), Integer.SIZE);
1449     Assert.assertEquals(Integer.numberOfLeadingZeros(1), Integer.SIZE - 1);
1450     Assert.assertEquals(Integer.numberOfLeadingZeros(1 << (Integer.SIZE-1)), 0);
1451     Assert.assertEquals(Integer.numberOfLeadingZeros($noinline$return_int_zero()), Integer.SIZE);
1453         Assert.assertEquals(Integer.numberOfLeadingZeros(1 << i), Integer.SIZE - 1 - i);
1454         Assert.assertEquals(Integer.numberOfLeadingZeros((1 << i) | 1), Integer.SIZE - 1 - i);
1455         Assert.assertEquals(Integer.numberOfLeadingZeros(0xFFFFFFFF >>> i), i);
1467     Assert.assertEquals(Long.numberOfLeadingZeros(0L), Long.SIZE);
1468     Assert.assertEquals(Long.numberOfLeadingZeros(1L), Long.SIZE - 1);
1469     Assert.assertEquals(Long.numberOfLeadingZeros(1L << ((Long.SIZE/2)-1)), Long.SIZE/2);
1470     Assert.assertEquals(Long.numberOfLeadingZeros(1L << (Long.SIZE-1)), 0);
1471     Assert.assertEquals(Long.numberOfLeadingZeros($noinline$return_long_zero()), Long.SIZE);
1473         Assert.assertEquals(Long.numberOfLeadingZeros(1L << i), Long.SIZE - 1 - i);
1474         Assert.assertEquals(Long.numberOfLeadingZeros((1L << i) | 1L), Long.SIZE - 1 - i);
1475         Assert.assertEquals(Long.numberOfLeadingZeros(0xFFFFFFFFFFFFFFFFL >>> i), i);
1514     Assert.assertEquals((byte)peek_byte.invoke(null, address), 0x12);
1515     Assert.assertEquals((byte)peek_byte.invoke(null, address + 1), 0x11);
1525     Assert.assertEquals((short)peek_short.invoke(null, address, false), 0x1213);  // Aligned read
1526 …Assert.assertEquals((short)peek_short.invoke(null, address + 1, false), 0x1112);  // Unaligned read
1538     Assert.assertEquals((int)peek_int.invoke(null, address, false), 0x12131415);
1539     Assert.assertEquals((int)peek_int.invoke(null, address + 1, false), 0x11121314);
1555     Assert.assertEquals((long)peek_long.invoke(null, address, false), 0x1213141516171819L);
1556     Assert.assertEquals((long)peek_long.invoke(null, address + 1, false), 0x1112131415161718L);
1613     Assert.assertEquals(Integer.numberOfTrailingZeros(0), Integer.SIZE);
1615       Assert.assertEquals(
1618       Assert.assertEquals(
1621       Assert.assertEquals(Integer.numberOfTrailingZeros(1 << i), i);
1626     Assert.assertEquals(Long.numberOfTrailingZeros(0), Long.SIZE);
1628       Assert.assertEquals(
1631       Assert.assertEquals(
1634       Assert.assertEquals(Long.numberOfTrailingZeros(1L << i), i);
1639     Assert.assertEquals(Integer.rotateRight(0x11, 0), 0x11);
1641     Assert.assertEquals(Integer.rotateRight(0x11, 1), 0x80000008);
1642     Assert.assertEquals(Integer.rotateRight(0x11, Integer.SIZE - 1), 0x22);
1643     Assert.assertEquals(Integer.rotateRight(0x11, Integer.SIZE), 0x11);
1644     Assert.assertEquals(Integer.rotateRight(0x11, Integer.SIZE + 1), 0x80000008);
1646     Assert.assertEquals(Integer.rotateRight(0x11, -1), 0x22);
1647     Assert.assertEquals(Integer.rotateRight(0x11, -(Integer.SIZE - 1)), 0x80000008);
1648     Assert.assertEquals(Integer.rotateRight(0x11, -Integer.SIZE), 0x11);
1649     Assert.assertEquals(Integer.rotateRight(0x11, -(Integer.SIZE + 1)), 0x22);
1651     Assert.assertEquals(Integer.rotateRight(0x80000000, 1), 0x40000000);
1654       Assert.assertEquals(
1661     Assert.assertEquals(Long.rotateRight(0x11, 0), 0x11);
1663     Assert.assertEquals(Long.rotateRight(0x11, 1), 0x8000000000000008L);
1664     Assert.assertEquals(Long.rotateRight(0x11, Long.SIZE - 1), 0x22);
1665     Assert.assertEquals(Long.rotateRight(0x11, Long.SIZE), 0x11);
1666     Assert.assertEquals(Long.rotateRight(0x11, Long.SIZE + 1), 0x8000000000000008L);
1668     Assert.assertEquals(Long.rotateRight(0x11, -1), 0x22);
1669     Assert.assertEquals(Long.rotateRight(0x11, -(Long.SIZE - 1)), 0x8000000000000008L);
1670     Assert.assertEquals(Long.rotateRight(0x11, -Long.SIZE), 0x11);
1671     Assert.assertEquals(Long.rotateRight(0x11, -(Long.SIZE + 1)), 0x22);
1673     Assert.assertEquals(Long.rotateRight(0x8000000000000000L, 1), 0x4000000000000000L);
1676       Assert.assertEquals(
1683     Assert.assertEquals(Integer.rotateLeft(0x11, 0), 0x11);
1685     Assert.assertEquals(Integer.rotateLeft(0x11, 1), 0x22);
1686     Assert.assertEquals(Integer.rotateLeft(0x11, Integer.SIZE - 1), 0x80000008);
1687     Assert.assertEquals(Integer.rotateLeft(0x11, Integer.SIZE), 0x11);
1688     Assert.assertEquals(Integer.rotateLeft(0x11, Integer.SIZE + 1), 0x22);
1690     Assert.assertEquals(Integer.rotateLeft(0x11, -1), 0x80000008);
1691     Assert.assertEquals(Integer.rotateLeft(0x11, -(Integer.SIZE - 1)), 0x22);
1692     Assert.assertEquals(Integer.rotateLeft(0x11, -Integer.SIZE), 0x11);
1693     Assert.assertEquals(Integer.rotateLeft(0x11, -(Integer.SIZE + 1)), 0x80000008);
1695     Assert.assertEquals(Integer.rotateLeft(0xC0000000, 1), 0x80000001);
1698       Assert.assertEquals(
1705     Assert.assertEquals(Long.rotateLeft(0x11, 0), 0x11);
1707     Assert.assertEquals(Long.rotateLeft(0x11, 1), 0x22);
1708     Assert.assertEquals(Long.rotateLeft(0x11, Long.SIZE - 1), 0x8000000000000008L);
1709     Assert.assertEquals(Long.rotateLeft(0x11, Long.SIZE), 0x11);
1710     Assert.assertEquals(Long.rotateLeft(0x11, Long.SIZE + 1), 0x22);
1712     Assert.assertEquals(Long.rotateLeft(0x11, -1), 0x8000000000000008L);
1713     Assert.assertEquals(Long.rotateLeft(0x11, -(Long.SIZE - 1)), 0x22);
1714     Assert.assertEquals(Long.rotateLeft(0x11, -Long.SIZE), 0x11);
1715     Assert.assertEquals(Long.rotateLeft(0x11, -(Long.SIZE + 1)), 0x8000000000000008L);
1717     Assert.assertEquals(Long.rotateLeft(0xC000000000000000L, 1), 0x8000000000000001L);
1720       Assert.assertEquals(
1728       Assert.assertEquals(Integer.rotateLeft(0xBBAAAADD, i),
1730       Assert.assertEquals(Integer.rotateLeft(0xBBAAAADD, -i),
1737       Assert.assertEquals(Long.rotateLeft(0xBBAAAADDFF0000DDL, i),
1739       Assert.assertEquals(Long.rotateLeft(0xBBAAAADDFF0000DDL, -i),