/* 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.wonka.lang.Float;
import gnu.testlet.Testlet;
import gnu.testlet.TestHarness;
public class FloatTest implements Testlet
{
protected static TestHarness harness;
public void test_Basics()
{
Float nan1 = new Float(0.0f/0.0f);
Float nan2 = new Float(Float.NaN);
float min1 = 1.4e-45f;
float min2 = Float.MIN_VALUE;
float max1 = 3.4028235e+38f;
float max2 = Float.MAX_VALUE;
float ninf1 = -1.0f/0.0f;
float ninf2 = Float.NEGATIVE_INFINITY;
float pinf1 = 1.0f/0.0f;
float pinf2 = Float.POSITIVE_INFINITY;
harness.check(!( min1 != min2 || max1 != max2 ||
ninf1 != ninf2 || pinf1 != pinf2 ||
!nan2.equals(nan1) ),
"test_Basics - 1" );
Float i1 = new Float(100.5f);
harness.check(!( i1.floatValue() != 100.5f ),
"test_Basics - 2" );
try {
harness.check(!( (new Float("234.34f")).floatValue() != 234.34f ),
"test_Basics - 3" );
}
catch ( NumberFormatException e )
{
harness.fail("test_Basics - 3" );
}
if (!System.getProperty("os.name").equals("VxWorks")){
// bug EJWcr00687, has not been fixed yet.
// Test is disabled for smallvm 2.0.1 release.
try {
harness.check(!( (new Float("1.4e-45f")).floatValue() != 1.4e-45f ),
"test_Basics - 4" );
}
catch ( NumberFormatException e )
{
harness.fail("test_Basics - 4" );
}
}
try {
new Float("babu");
harness.fail("test_Basics - 5" );
}
catch ( NumberFormatException e )
{
}
harness.check(!( (new Float(3.4)).floatValue() != 3.4f ),
"test_Basics - 6" );
Float nan = new Float(Float.NaN );
harness.check(!( !nan.isNaN()),
"test_Basics - 7" );
harness.check(!( (new Float(10.0f)).isNaN()),
"test_Basics - 8" );
harness.check(!( !Float.isNaN( Float.NaN )),
"test_Basics - 9" );
harness.check(!( !(new Float(Float.POSITIVE_INFINITY)).isInfinite()),
"test_Basics - 10" );
harness.check(!( !(new Float(Float.NEGATIVE_INFINITY)).isInfinite()),
"test_Basics - 11" );
harness.check(!( !(Float.isInfinite( Float.POSITIVE_INFINITY))),
"test_Basics - 12" );
harness.check(!( !(Float.isInfinite( Float.NEGATIVE_INFINITY))),
"test_Basics - 13" );
harness.check(!( Float.isInfinite( 2.30f )),
"test_Basics - 14" );
}
public void test_toString()
{
harness.check(!( !( new Float(123.0f)).toString().equals("123.0")),
"test_toString - 1" );
harness.check(new Float(-44.5343f).toString(),"-44.5343",
"test_toString - 2" );
harness.check(Float.toString( 23.04f ),"23.04" ,
"test_toString - 3" );
harness.check(!( !Float.toString( Float.NaN ).equals ("NaN" )),
"test_toString - 4" );
harness.check(!( !Float.toString( Float.POSITIVE_INFINITY ).equals ("Infinity" )),
"test_toString - 5" );
harness.check(!( !Float.toString( Float.NEGATIVE_INFINITY ).equals ("-Infinity" )),
"test_toString - 6" );
harness.check(!( !Float.toString( 0.0f ).equals ("0.0" )),
"test_toString - 7" );
String str;
str = Float.toString( -0.0f );
harness.check(!( !str.equals ("-0.0" )),
"test_toString - 8" );
str = Float.toString( -912125.45f);
if ( !str.equals ("-912125.44" )) {
harness.fail("test_toString - 9" );
System.out.println("Bug EJWcr00027");
System.out.println("expected '-912125.45', got '" +
str + "'");
}
// 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 = Float.toString( 0.001f );
harness.check(!( !Float.toString( 0.001f ).equals ("0.001" )),
"test_toString - 10" );
str = Float.toString(33333333.33f );
if ( !(new Float( str)).equals(new Float(33333333.33f))) {
harness.fail("test_toString - 11" );
System.out.println("Bug EJWcr00029");
int i = Float.floatToIntBits(new Float( str).floatValue());
int j = Float.floatToIntBits(new Float(33333333.33f).floatValue());
int k = Float.floatToIntBits(33333333.33f);
System.out.println("ours = " + Integer.toHexString(i));
System.out.println("javac's = " + Integer.toHexString(j));
System.out.println("plain constant = " + Integer.toHexString(k));
}
str = Float.toString(-123232324253.32f );
if ( !(new Float( str)).equals(new Float(-123232324253.32f))) {
harness.fail("test_toString - 12" );
System.out.println("Bug EJWcr00030");
int i = Float.floatToIntBits(new Float( str).floatValue());
int j = Float.floatToIntBits(new Float(-123232324253.32f).floatValue());
int k = Float.floatToIntBits(-123232324253.32f);
System.out.println("ours = " + Integer.toHexString(i));
System.out.println("javac's = " + Integer.toHexString(j));
System.out.println("plain constant = " + Integer.toHexString(k));
}
str = Float.toString(1.243E10f);
harness.check(!( !(new Float( str)).equals(new Float(1.243E10f))),
"test_toString - 13" );
str = Float.toString(-23.43E33f);
harness.check(!( !(new Float( str)).equals(new Float(-23.43E33f))),
"test_toString - 14" );
str = Float.toString(Float.MIN_VALUE);
if(!str.equals("1.4E-45")) {
harness.fail("test_toString - 15" );
harness.debug("Expected : 1.4E-45");
harness.debug("Got: " + str);
}
}
public void test_equals()
{
Float i1 = new Float(2334.34E4);
Float i2 = new Float(-2334.34E4);
harness.check(!( !i1.equals( new Float(2334.34E4))),
"test_equals - 1" );
harness.check(!( !i2.equals( new Float(-2334.34E4))),
"test_equals - 2" );
harness.check(!( i1.equals( i2 )),
"test_equals - 3" );
harness.check(!( i1.equals(null)),
"test_equals - 4" );
float n1 = Float.NaN;
float n2 = Float.NaN;
harness.check(!( n1 == n2 ),
"test_equals - 5" );
Float flt1 = new Float( Float.NaN);
Float flt2 = new Float( Float.NaN);
harness.check(!( !flt1.equals(flt2)),
"test_equals - 6" );
harness.check(!( 0.0f != -0.0f ),
"test_equals - 7" );
Float pzero = new Float( 0.0f );
Float nzero = new Float( -0.0f );
harness.check(!( pzero.equals(nzero) ),
"test_equals - 8" );
}
public void test_hashCode( )
{
Float flt1 = new Float(3.4028235e+38f);
harness.check(!( flt1.hashCode() != Float.floatToIntBits( 3.4028235e+38f )),
"test_hashCode - 1");
Float flt2 = new Float( -2343323354f );
harness.check(!( flt2.hashCode() != Float.floatToIntBits( -2343323354f )),
"test_hashCode - 2");
}
public void test_intValue( )
{
Float b1 = new Float(3.4e+32f);
Float b2 = new Float(-23.45f);
int i1 = b1.intValue();
int i2 = b2.intValue();
harness.check(!( i1 != (int) 3.4e+32f),
"test_intValue - 1" );
harness.check(!( i2 != (int) -23.45f ),
"test_intValue - 2" );
}
public void test_longValue( )
{
Float b1 = new Float(3.4e+15f);
Float b2 = new Float(-23.45f);
float b3 = 3.4e+15f;
long l3 = (long)b3;
harness.check(!( b1.longValue() != l3),
"test_longValue - 1" );
b3 = -23.45f;
l3 = (long)b3;
harness.check(!( b2.longValue() != l3),
"test_longValue - 2" );
}
public void test_floatValue( )
{
Float b1 = new Float(3276.34f);
Float b2 = new Float(-3276.32);
harness.check(!( b1.floatValue() != 3276.34f ),
"test_floatValue - 1" );
harness.check(!( b2.floatValue() != -3276.32f ),
"test_floatValue - 2" );
}
public void test_doubleValue( )
{
Float b1 = new Float(0.0f);
Float b2 = new Float(30.0f);
harness.check(!( b1.doubleValue() != 0.0 ),
"test_doubleValue - 1" );
harness.check(!( b2.doubleValue() != 30.0 ),
"test_doubleValue - 2" );
}
public void test_valueOf( )
{
try {
Float.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 {
Float.valueOf("Kona");
harness.fail("test_valueOf - 2" );
}catch( NumberFormatException e)
{harness.check(true, "test_valueOf Kona");}
try {
harness.check(!( Float.valueOf( "3.4e+32f" ).floatValue() != 3.4e+32f ),
"test_valueOf - 3" );
}catch( NumberFormatException e)
{harness.check(false, "test_valueOf 3.4e+32f");}
try {
harness.check(!( Float.valueOf(" -23.45f ").floatValue() != -23.45f ),
"test_valueOf - 4" );
}catch( NumberFormatException e)
{harness.check(false, "test_valueOf \" -23.45f \"");}
}
public void test_parseFloat( )
{
try {
Float.parseFloat(null);
harness.fail("test_parseFloat - 1" );
}
catch ( NumberFormatException nfe )
{harness.check(false, "test_parseFloat null should throw NullPointerException");}
catch ( NullPointerException e )
{harness.check(true, "test_parseFloat null");}
try {
Float.parseFloat("Kona");
harness.fail("test_parseFloat - 2" );
}catch( NumberFormatException e)
{harness.check(true, "test_parseFloat Kona");}
try {
harness.check(!( Float.parseFloat( "3.4e+32f" ) != 3.4e+32f ),
"test_parseFloat - 3" );
}catch( NumberFormatException e)
{harness.check(false, "test_parseFloat 3.4e+32f");}
try {
harness.check(!( Float.parseFloat(" -23.45f ") != -23.45f ),
"test_parseFloat - 4" );
}catch( NumberFormatException e)
{harness.check(false, "test_parseFloat \" -23.45f \"");}
}
public void test_floatToIntBits()
{
harness.check(!( Float.floatToIntBits( Float.POSITIVE_INFINITY ) != 0x7f800000 ),
"test_floatToIntBits - 1" );
harness.check(!( Float.floatToIntBits( Float.NEGATIVE_INFINITY ) != 0xff800000 ),
"test_floatToIntBits - 2" );
int nanval = Float.floatToIntBits( Float.NaN );
harness.check(!( nanval != 0x7fc00000 ),
"test_floatToIntBits - 3" );
int i1 = Float.floatToIntBits(3.4e+32f);
int i2 = Float.floatToIntBits(-34.56f);
int sign1 = i1 & 0x80000000 ;
int sign2 = i2 & 0x80000000 ;
int exp1 = i1 & 0x7f800000 ;
int exp2 = i2 & 0x7f800000 ;
int man1 = i1 & 0x007fffff ;
int man2 = i2 & 0x007fffff ;
harness.check(!(sign1 != 0 ),
"test_floatToIntBits - 4" );
harness.check(!( sign2 != 0x80000000 ),
"test_floatToIntBits - 5" );
harness.check(!( exp1 != 1971322880 ),
"test_floatToIntBits - 6" );
harness.check(!( exp2 != 1107296256 ),
"test_floatToIntBits - 7" );
harness.check(!( man1 != 400186 ),
"test_floatToIntBits - 8" );
harness.check(!( man2 != 671089 ),
"test_floatToIntBits - 9" );
}
public void test_intBitsToFloat( )
{
harness.check(!( Float.intBitsToFloat( 0x7f800000 ) != Float.POSITIVE_INFINITY ),
"test_intBitsToFloat - 1" );
harness.check(!( Float.intBitsToFloat( 0xff800000 ) != Float.NEGATIVE_INFINITY ),
"test_intBitsToFloat - 2" );
harness.check(!( !Float.isNaN(Float.intBitsToFloat( 0x7f800002 ))),
"test_intBitsToFloat - 3" );
harness.check(!( !Float.isNaN(Float.intBitsToFloat( 0x7f8ffff0 ))),
"test_intBitsToFloat - 4" );
harness.check(!( !Float.isNaN(Float.intBitsToFloat( 0xff800002 ) )),
"test_intBitsToFloat - 5" );
harness.check(!( !Float.isNaN(Float.intBitsToFloat( 0xfffffff1 ))),
"test_intBitsToFloat - 6" );
harness.check(!( !Float.isNaN(Float.intBitsToFloat( 0xffc00000 ))),
"test_intBitsToFloat - 7" );
float fl1 = Float.intBitsToFloat( 0x34343f34 );
harness.check(!( fl1 != 1.67868e-007f ),
"test_intBitsToFloat - 8" );
harness.check(!( Float.floatToIntBits( Float.intBitsToFloat(0x33439943)) != 0x33439943 ),
"test_intBitsToFloat - 9");
}
public void test_shortbyteValue()
{
Float d1 = new Float( 123.35 );
Float d2 = new Float( 400.35 );
Float d3 = new Float(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() {
float zero = 0.0f;
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");
}
zero = -zero;
String zero3 = String.valueOf(zero);
if (!zero3.equals("0.0")) {
harness.fail("test_neg - 3");
}
float nonzero = -12.24f;
String nonzero1 = String.valueOf(nonzero);
if (!nonzero1.equals("-12.24")) {
harness.fail("test_neg - 4: got "+nonzero1+", but wanted -12.24");
}
nonzero = -nonzero;
String nonzero2 = String.valueOf(nonzero);
if (!nonzero2.equals("12.24")) {
harness.fail("test_neg - 5: got "+nonzero2+", but wanted 12.24");
}
nonzero = -nonzero;
String nonzero3 = String.valueOf(nonzero);
if (!nonzero3.equals("-12.24")) {
harness.fail("test_neg - 6: got "+nonzero3+", but wanted -12.24");
}
}
public void testall()
{
test_Basics();
test_toString();
test_equals();
test_hashCode();
test_intValue();
test_longValue();
test_floatValue();
test_doubleValue();
test_shortbyteValue();
test_valueOf();
test_parseFloat();
test_floatToIntBits();
test_intBitsToFloat();
test_neg();
}
public void test (TestHarness the_harness)
{
harness = the_harness;
testall ();
}
}