--- a/tests/libjava-mauve/src/gnu/testlet/java/lang/Double/DoubleTest.java Fri Jul 20 21:39:51 2012 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,641 +0,0 @@
-/* Copyright (C) 1999, 2002 Hewlett-Packard Company
-
- This file is part of Mauve.
-
- Mauve is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
- any later version.
-
- Mauve is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with Mauve; see the file COPYING. If not, write to
- the Free Software Foundation, 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
-*/
-
-// Tags: JDK1.0
-
-package gnu.testlet.java.lang.Double;
-import gnu.testlet.Testlet;
-import gnu.testlet.TestHarness;
-
-public class DoubleTest implements Testlet
-{
-
- protected static TestHarness harness;
- public void test_Basics()
- {
- double min1 = 5e-324;
- double min2 = Double.MIN_VALUE;
- double max1 = 1.7976931348623157e+308;
- double max2 = Double.MAX_VALUE;
- double ninf1 = -1.0/0.0;
- double ninf2 = Double.NEGATIVE_INFINITY;
- double pinf1 = 1.0/0.0;
- double pinf2 = Double.POSITIVE_INFINITY;
- Double nan1 = new Double(0.0/0.0);
- Double nan2 = new Double(Double.NaN);
-
- if ( min1 != min2 ) {
- harness.fail("test_Basics - 1a");
- System.out.println("Expected: " + min1);
- System.out.println("Got: " + min2);
- }
- if ( max1 != max2 ) {
- harness.fail("test_Basics - 1b");
- System.out.println("Expected: " + max1);
- System.out.println("Got: " + max2);
- }
- if (ninf1 != ninf2) {
- harness.fail("test_Basics - 1c");
- System.out.println("Expected: " + ninf1);
- System.out.println("Got: " + ninf2);
- }
- if (pinf1 != pinf2) {
- harness.fail("test_Basics - 1d");
- System.out.println("Expected: " + pinf1);
- System.out.println("Got: " + pinf2);
- }
- if (!nan2.equals(nan1) ) {
- harness.fail("test_Basics CYGNUS: NaN.equals - 1e");
- System.out.println("Expected: " + nan1);
- System.out.println("Got: " + nan2);
- }
-
- Double i1 = new Double(100.5);
-
- harness.check(!( i1.doubleValue() != 100.5 ),
- "test_Basics - 2" );
-
-
- try {
- harness.check(!( (new Double("234.34")).doubleValue() != 234.34 ),
- "test_Basics - 3" );
- }
- catch ( NumberFormatException e )
- {
- harness.fail("test_Basics - 3" );
- }
-
- try {
- harness.check(!( (new Double("1.4e-45")).doubleValue() != 1.4e-45 ),
- "test_Basics - 4" );
- }
- catch ( NumberFormatException e )
- {
- harness.fail("test_Basics - 4" );
- }
-
- try {
- new Double("babu");
- harness.fail("test_Basics - 5" );
- }
- catch ( NumberFormatException e )
- {
- }
-
- harness.check(!( (new Double(3.4)).doubleValue() != 3.4 ),
- "test_Basics - 6" );
-
-
- Double nan = new Double(Double.NaN );
- harness.check(!( !nan.isNaN()),
- "test_Basics - 7" );
-
- harness.check(!( (new Double(10.0f)).isNaN()),
- "test_Basics - 8" );
-
- harness.check(!( !Double.isNaN( Double.NaN )),
- "test_Basics - 9" );
-
- harness.check(!( !(new Double(Double.POSITIVE_INFINITY)).isInfinite()),
- "test_Basics - 10" );
-
- harness.check(!( !(new Double(Double.NEGATIVE_INFINITY)).isInfinite()),
- "test_Basics - 11" );
- harness.check(!( !( Double.isInfinite( Double.NEGATIVE_INFINITY))),
- "test_Basics - 12" );
- harness.check(!( !( Double.isInfinite( Double.POSITIVE_INFINITY))),
- "test_Basics - 13" );
- harness.check(!( 0.0 - 0.0 != 0.0),
- "test_Basics - 14" );
- harness.check(!( 0.0 + 0.0 != 0.0),
- "test_Basics - 15" );
- harness.check(!( 0.0 + -0.0 != 0.0),
- "test_Basics - 16" );
- harness.check(!( 0.0 - -0.0 != 0.0),
- "test_Basics - 17" );
- harness.check(!( -0.0 - 0.0 != -0.0),
- "test_Basics - 18" );
- harness.check(!( -0.0 + 0.0 != 0.0),
- "test_Basics - 19" );
- harness.check(!( -0.0 + -0.0 != -0.0),
- "test_Basics - 20" );
- harness.check(!( -0.0 - -0.0 != 0.0),
- "test_Basics - 21" );
-
- harness.check(!( !"0.0".equals(0.0 - 0.0 +"" )),
- "test_Basics - 22" );
-
- }
-
- public void test_toString()
- {
- harness.check(!( !( new Double(123.0)).toString().equals("123.0")),
- "test_toString - 1" );
- harness.check(!( !( new Double(-44.5343)).toString().equals("-44.5343")),
- "test_toString - 2" );
-
- harness.check(!( !Double.toString( 23.04 ).equals ("23.04" )),
- "test_toString - 3" );
-
- harness.check(!( !Double.toString( Double.NaN ).equals ("NaN" )),
- "test_toString - 4" );
-
- harness.check(!( !Double.toString( Double.POSITIVE_INFINITY ).equals ("Infinity" )),
- "test_toString - 5" );
- harness.check(!( !Double.toString( Double.NEGATIVE_INFINITY ).equals ("-Infinity" )),
- "test_toString - 6" );
-
- harness.check(!( !Double.toString( 0.0 ).equals ("0.0" )),
- "test_toString - 7" );
-
- String str;
-
- str = Double.toString( -0.0 );
- harness.check(!( !str.equals ("-0.0" )),
- "test_toString - 8" );
-
- str = Double.toString( -9412128.34 );
- harness.check(!( !str.equals ("-9412128.34" )),
- "test_toString - 9" );
-
- // The following case fails for some Sun JDKs (e.g. 1.3.1
- // and 1.4.0) where toString(0.001) returns "0.0010". This
- // is contrary to the JDK 1.4 javadoc. This particular
- // case has been noted as a comment to Sun Java bug #4642835
- str = Double.toString( 0.001 );
- if ( !Double.toString( 0.001 ).equals ("0.001" )) {
- harness.fail("test_toString - 10" );
- System.out.println("Expected: " + "0.001");
- System.out.println("Got: " + Double.toString(0.001));
- }
-
- str = Double.toString( 1e4d );
- if ( !Double.toString( 1e4d ).equals ("10000.0" )) {
- harness.fail("test_toString - 11" );
- System.out.println("Expected: " + "10000.0");
- System.out.println("Got: " + Double.toString(1e4d));
- }
-
- str = Double.toString(33333333.33 );
- if ( !(new Double( str)).equals(new Double(33333333.33))) {
- harness.fail("test_toString - 12" );
- System.out.println("Expected: " +
- (new Double(33333333.33)).toString());
- System.out.println("Got: " +
- (new Double(str)).toString());
- }
- str = Double.toString(-123232324253.32 );
- if ( !(new Double( str)).equals(new Double(-123232324253.32))) {
- harness.fail("test_toString - 13" );
- System.out.println("Expected: " +
- (new Double(-123232324253.32)).toString());
- System.out.println("Got: " +
- (new Double(str)).toString());
- }
- str = Double.toString(1.243E10);
- if ( !(new Double( str)).equals(new Double(1.243E10))) {
- harness.fail("test_toString - 14" );
- System.out.println("Expected: " +
- (new Double(1.243E10)).toString());
- System.out.println("Got: " +
- (new Double(str)).toString());
- }
- str = Double.toString(Double.MIN_VALUE);
- if ( !str.equals("4.9E-324")) {
- harness.fail("test_toString - 15" );
- harness.debug("Expected: 4.9E-324");
- harness.debug("Got: " + str);
- }
-
- /*
- str = Double.toString(-23.43E33);
- if ( !(new Double( str)).equals(new Double(-23.43E33)))
- harness.fail("test_toString - 16" );
- */
-
- }
-
- public void test_equals()
- {
- Double i1 = new Double(2334.34E4);
- Double i2 = new Double(-2334.34E4);
-
- harness.check(!( !i1.equals( new Double(2334.34E4))),
- "test_equals - 1" );
- harness.check(!( !i2.equals( new Double(-2334.34E4))),
- "test_equals - 2" );
-
-
- harness.check(!( i1.equals( i2 )),
- "test_equals - 3" );
-
- harness.check(!( i1.equals(null)),
- "test_equals - 4" );
-
- double n1 = Double.NaN;
- double n2 = Double.NaN;
- harness.check(!( n1 == n2 ),
- "test_equals - 5" );
-
- Double flt1 = new Double( Double.NaN);
- Double flt2 = new Double( Double.NaN);
- harness.check(!( !flt1.equals(flt2)),
- "test_equals CYGNUS: NaN.equals - 6" );
-
- harness.check(!( 0.0 != -0.0 ),
- "test_equals - 7" );
-
- Double pzero = new Double( 0.0 );
- Double nzero = new Double( -0.0 );
-
- harness.check(!( pzero.equals(nzero) ),
- "test_equals CYGNUS: Double.equals - 8" );
-
- }
-
-
- public void test_hashCode( )
- {
- Double flt1 = new Double(3.4028235e+38);
- long lng1 = Double.doubleToLongBits( 3.4028235e+38);
-
- harness.check(!( flt1.hashCode() != (int) ( lng1^(lng1>>>32)) ),
- "test_hashCode - 1");
-
- Double flt2 = new Double( -2343323354.0 );
- long lng2 = Double.doubleToLongBits( -2343323354.0 );
-
- harness.check(!( flt2.hashCode() != (int) ( lng2^(lng2>>>32)) ),
- "test_hashCode - 2");
- }
-
- public void test_intValue( )
- {
- Double b1 = new Double(3.4e+32);
- Double b2 = new Double(-23.45);
-
- int i1 = b1.intValue();
- int i2 = b2.intValue();
-
- harness.check(!( i1 != (int) 3.4e+32),
- "test_intValue CYGNUS: Float to int conversions - 1" );
-
- harness.check(!( i2 != (int) -23.45 ),
- "test_intValue - 2" );
- Double b3 = new Double(3000.54);
- harness.check(!( b3.intValue() != 3000 ),
- "test_intValue - 3" );
- Double b4 = new Double(32735.3249);
- harness.check(!( b4.intValue() != 32735 ),
- "test_intValue - 4" );
- Double b5 = new Double(-32735.3249);
- harness.check(!( b5.intValue() != -32735 ),
- "test_intValue - 5" );
- Double b6 = new Double(-32735.3249);
- harness.check(!( b6.intValue() != -32735 ),
- "test_intValue - 6" );
- Double b7 = new Double(0.0);
- harness.check(!( b7.intValue() != 0 ),
- "test_intValue - 7" );
- }
-
- public void test_longValue( )
- {
- Double b1 = new Double(3.4e+32);
- Double b2 = new Double(-23.45);
-
- harness.check(!( b1.longValue() != (long) 3.4e+32),
- "test_longValue CYGNUS: Float to int conversions - 1" );
-
- harness.check(!( b2.longValue() != (long) -23.45 ),
- "test_longValue - 2" );
- }
-
- public void test_DoubleValue( )
- {
- Double b1 = new Double(3276.34);
- Double b2 = new Double(-3276.32);
-
- harness.check(!( b1.doubleValue() != 3276.34 ),
- "test_DoubleValue - 1" );
-
- harness.check(!( b2.doubleValue() != -3276.32 ),
- "test_DoubleValue - 2" );
- }
-
- public void test_doubleValue( )
- {
- Double b1 = new Double(0.0);
- Double b2 = new Double(30.0);
-
- harness.check(!( b1.doubleValue() != 0.0 ),
- "test_doubleValue - 1" );
-
- harness.check(!( b2.doubleValue() != 30.0 ),
- "test_doubleValue - 2" );
- }
-
- public void test_floatValue( )
- {
- Double b1 = new Double(0.0);
- Double b2 = new Double(30.0);
-
- harness.check(!( b1.floatValue() != 0.0f ),
- "test_floatValue - 1" );
-
- harness.check(!( b2.floatValue() != 30.0f ),
- "test_floatValue - 2" );
- }
-
- public void test_valueOf( )
- {
- try {
- Double.valueOf(null);
- harness.fail("test_valueOf - 1" );
- }
- catch ( NumberFormatException nfe )
- {harness.check(false, "test_valueOf null should throw NullPointerException");}
- catch ( NullPointerException e )
- {harness.check(true, "test_valueOf null");}
-
- try {
- Double.valueOf("Kona");
- harness.fail("test_valueOf - 2" );
- }catch( NumberFormatException e) {}
-
- harness.check(!( Double.valueOf( "3.4e+32" ).doubleValue() != 3.4e+32 ),
- "test_valueOf - 3" );
-
- harness.check(!( Double.valueOf(" -23.45 ").doubleValue() != -23.45 ),
- "test_valueOf - 4" );
- }
-
- public void test_parseDouble( )
- {
- try {
- Double.parseDouble(null);
- harness.fail("test_parseDouble - 1" );
- }
- catch ( NumberFormatException nfe )
- {harness.check(false, "test_parseDouble null should throw NullPointerException");}
- catch ( NullPointerException e )
- {harness.check(true, "test_parseDouble null");}
-
- try {
- Double.parseDouble("Kona");
- harness.fail("test_parseDouble - 2" );
- }catch( NumberFormatException e) {}
-
- harness.check(!( Double.parseDouble( "3.4e+32" ) != 3.4e+32 ),
- "test_parseDouble - 3" );
-
- harness.check(!( Double.parseDouble(" -23.45 ") != -23.45 ),
- "test_parseDouble - 4" );
- }
-
- public void test_doubleToLongBits()
- {
- harness.check(!( Double.doubleToLongBits( Double.POSITIVE_INFINITY ) != 0x7ff0000000000000L ),
- "test_doubleToLongBits - 1" );
- harness.check(!( Double.doubleToLongBits( Double.NEGATIVE_INFINITY ) != 0xfff0000000000000L ),
- "test_doubleToLongBits - 2" );
-
- long nanval = Double.doubleToLongBits( Double.NaN );
- harness.check(!( nanval != 0x7ff8000000000000L ),
- "test_doubleToLongBits CYGNUS: NaN.doubleToLongBits" );
-
- long i1 = Double.doubleToLongBits(3.4e+32f);
- long i2 = Double.doubleToLongBits(-34.56f);
-
- long sign1 = i1 & 0x8000000000000000L ;
- long sign2 = i2 & 0x8000000000000000L ;
-
- long exp1 = i1 & 0x7ff0000000000000L ;
- long exp2 = i2 & 0x7ff0000000000000L ;
-
- long man1 = i1 & 0x000fffffffffffffL ;
- long man2 = i2 & 0x000fffffffffffffL ;
-
- harness.check(!(sign1 != 0 ),
- "test_doubleToLongBits - 4" );
-
- harness.check(!( sign2 != 0x8000000000000000L ),
- "test_doubleToLongBits - 5" );
-
- harness.check(!( exp1 != 5093571178556030976L ),
- "test_doubleToLongBits - 6" );
-
- harness.check(!( exp2 != 4629700416936869888L ),
- "test_doubleToLongBits - 7" );
-
- harness.check(!( man1 != 214848222789632L ),
- "test_doubleToLongBits - 8" );
-
- harness.check(!( man2 != 360288163463168L ),
- "test_doubleToLongBits - 9" );
-
- }
-
- public void test_longBitsToDouble( )
- {
- harness.check(!( Double.longBitsToDouble( 0x7ff0000000000000L) != Double.POSITIVE_INFINITY ),
- "test_longBitsToDouble - 1" );
- harness.check(!( Double.longBitsToDouble( 0xfff0000000000000L ) != Double.NEGATIVE_INFINITY ),
- "test_longBitsToDouble - 2" );
-
-
- harness.check(!( !Double.isNaN(Double.longBitsToDouble( 0xfff8000000000000L ))),
- "test_longBitsToDouble - 3" );
-
- harness.check(!( !Double.isNaN(Double.longBitsToDouble( 0x7ffffff000000000L ))),
- "test_longBitsToDouble - 4" );
-
- harness.check(!( !Double.isNaN(Double.longBitsToDouble( 0xfff8000020000001L ))),
- "test_longBitsToDouble - 5" );
-
- harness.check(!( !Double.isNaN(Double.longBitsToDouble( 0xfffffffffffffff1L ))),
- "test_longBitsToDouble - 6" );
-
- double fl1 = Double.longBitsToDouble( 0x34343f33 );
-
- if ( Double.doubleToLongBits(fl1) != 0x34343f33 ) {
- harness.fail("test_longBitsToDouble - 7" );
- System.out.println("Expected: " + Long.toHexString(0x34343f33));
- System.out.println("Got: " + Long.toHexString(Double.doubleToLongBits(fl1)));
- }
-
- harness.check(!( Double.doubleToLongBits( Double.longBitsToDouble(0x33439943)) != 0x33439943 ),
- "test_longBitsToDouble - 8");
- }
-
- public void check_remainder( double val, double val1 ,
- double ret , int errno )
- {
- double res = val % val1;
- harness.check(!( res < ret - 0.001 || res > ret + 0.001 ),
- "test_remainder " + errno );
- }
-
- public void check_remainder_NaN( double val, double val1 ,
- int errno )
- {
- double res = val % val1;
- if (!Double.isNaN(res)) {
- harness.fail("test_remainder " +
- errno);
- }
- }
-
- public void test_remainder( )
- {
- check_remainder(15.2 , 1.0 , 0.2, 1 );
- check_remainder(2345.2432 , 1.2 ,0.44319999999997 , 2 );
- check_remainder(20.56 , 1.87 ,1.8600000000000 , 3 );
- check_remainder(0.0 , 1.2 , 0.00000000000000 , 4 );
- check_remainder(1000 , 10 , 0.00000000000000 , 5 );
- check_remainder(234.332 , 134.34 , 99.992000000000 , 6 );
- check_remainder(1.0 , 1.0, 0.0 , 7 );
- check_remainder(45.0 , 5.0, 0.0 , 8 );
- check_remainder(1.25 , 0.50 , 0.25 , 9 );
- check_remainder(12345.678, 1234.5678, 1234.5678000000 , 10 );
-
- if (!System.getProperty("os.name").equals("VxWorks")){
- // bug EJWcr00686, has not been fixed yet.
- // Test is disabled for smallvm 2.0.1 release.
- check_remainder(Double.MAX_VALUE , Double.MIN_VALUE , 0.00000000000000 , 11 );
- }
-
- check_remainder(0.0 , 999.99, 0.00000000000000 , 12 );
- check_remainder(123.0 , 25.0 , 23.0 , 13 );
- check_remainder(15.0 , 1.5 , 0.00 , 14 );
- check_remainder_NaN(Double.NaN, 1.5 , 15 );
- check_remainder_NaN(1.5, Double.NaN, 16 );
- check_remainder_NaN(Double.NaN, 0, 17 );
- check_remainder_NaN(0, Double.NaN, 18 );
- check_remainder_NaN(Double.POSITIVE_INFINITY, 1.5, 19 );
- check_remainder_NaN(Double.NEGATIVE_INFINITY, 1.5, 20 );
- check_remainder_NaN(1.5, 0, 21 );
- check_remainder_NaN(Double.POSITIVE_INFINITY, 0, 22 );
- check_remainder_NaN(Double.NEGATIVE_INFINITY, 0, 23 );
- // EJWcr00505
- check_remainder(15.0 , Double.POSITIVE_INFINITY, 15.0 , 24 );
- check_remainder(-15.0 , Double.POSITIVE_INFINITY, -15.0 , 25 );
- check_remainder(0.0 , Double.POSITIVE_INFINITY, 0.0 , 26 );
- check_remainder(-0.0 , Double.POSITIVE_INFINITY, -0.0 , 27 );
- check_remainder(0.1 , Double.POSITIVE_INFINITY, 0.1 , 28 );
- check_remainder(-0.1 , Double.POSITIVE_INFINITY, -0.1 , 29 );
-
- check_remainder(15.0 , Double.NEGATIVE_INFINITY, 15.0 , 30 );
- check_remainder(-15.0 , Double.NEGATIVE_INFINITY, -15.0 , 31 );
- check_remainder(0.0 , Double.NEGATIVE_INFINITY, 0.0 , 32 );
- check_remainder(-0.0 , Double.NEGATIVE_INFINITY, -0.0 , 33 );
- check_remainder(0.1 , Double.NEGATIVE_INFINITY, 0.1 , 34 );
- check_remainder(-0.1 , Double.NEGATIVE_INFINITY, -0.1 , 35 );
-
-
- }
-
- public void test_shortbyteValue()
- {
- Double d1 = new Double( 123.35 );
- Double d2 = new Double( 400.35 );
- Double d3 = new Double(0.0 );
-
- harness.check(!( d1.shortValue() != 123 ),
- "test_shortbyteValue - 1" );
- harness.check(!( d2.shortValue() != 400 ),
- "test_shortbyteValue - 2" );
- harness.check(!( d3.shortValue() != 0 ),
- "test_shortbyteValue - 3" );
-
- harness.check(!( d1.byteValue() != 123 ),
- "test_shortbyteValue - 4" );
- harness.check(!( d2.byteValue() != (byte) 400 ),
- "test_shortbyteValue - 5" );
- harness.check(!( d3.byteValue() != 0 ),
- "test_shortbyteValue - 6" );
-
- }
-
- public void test_neg() {
- double zero = 0.0;
- String zero1 = String.valueOf(zero);
- if (!zero1.equals("0.0")) {
- harness.fail("test_neg - 1");
- }
-
- zero = -zero;
- String zero2 = String.valueOf(zero);
- if (!zero2.equals("-0.0")) {
- harness.fail("test_neg - 2");
- System.out.println("Expected -0.0, got: " + zero2);
- }
-
- zero = -zero;
- String zero3 = String.valueOf(zero);
- if (!zero3.equals("0.0")) {
- harness.fail("test_neg - 3");
- }
-
- double nonzero = -21.23;
- String nonzero1 = String.valueOf(nonzero);
- if (!nonzero1.equals("-21.23")) {
- harness.fail("test_neg - 4");
- }
-
- nonzero = -nonzero;
- String nonzero2 = String.valueOf(nonzero);
- if (!nonzero2.equals("21.23")) {
- harness.fail("test_neg - 5");
- }
-
- nonzero = -nonzero;
- String nonzero3 = String.valueOf(nonzero);
- if (!nonzero3.equals("-21.23")) {
- harness.fail("test_neg - 6");
- }
- }
- public void testall()
- {
- test_Basics();
- test_remainder();
- test_toString();
- test_equals();
- test_hashCode();
- test_intValue();
- test_longValue();
- test_DoubleValue();
- test_doubleValue();
- test_floatValue();
- test_shortbyteValue();
- test_valueOf();
- test_parseDouble();
- test_doubleToLongBits();
- test_longBitsToDouble();
- test_neg();
- }
-
- public void test (TestHarness the_harness)
- {
- harness = the_harness;
- testall ();
- }
-
-}