/* 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 ();
  }

}