# This file tests JavaNewCmd.java.
#
# This file contains a collection of tests for one or more of the Tcl
# built-in commands. Sourcing this file into Tcl runs the tests and
# generates output for errors. No output means no errors were found.
#
# Copyright (c) 1997 by Sun Microsystems, Inc.
#
# See the file "license.terms" for information on usage and redistribution
# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
#
# 2016 - reinserted in JBlend project
package require TTXN
# package under test is JBlend 2.0
package require JBlend 2.0
#
# JavaNewCmd.cmdProc
#
Name: javaNewCmd-1.1
Description: {JavaNewCmd.cmdProc}
Test: {
java::new
}
Expected: error {wrong # args: should be "java::new signature ?arg arg ...?"}
Name: javaNewCmd-1.2
Description: {JavaNewCmd.cmdProc}
Test: {
java::new {int[]}
}
Expected: error {wrong # args: should be "java::new int[] sizeList ?valueList?"}
Name: javaNewCmd-1.3
Description: {JavaNewCmd.cmdProc}
Test: {
java::new {blah[]} \{\{\}
}
Expected: error {unknown class "blah"}
Name: javaNewCmd-1.4
Description: {JavaNewCmd.cmdProc}
Test: {
java::new {blah[[]} \{\{\}
}
Expected: error {unknown class "blah["}
Name: javaNewCmd-1.5
Description: {JavaNewCmd.cmdProc}
Test: {
java::new {int[]} \{\{\}
}
Expected: error {unmatched open brace in list}
Name: javaNewCmd-1.6
Description: {JavaNewCmd.cmdProc}
Test: {
set x [java::new {int[]} {} {0 1 2 3 4}]
list [$x get 0] [$x get 4]
}
Expected: {0 4}
Name: javaNewCmd-1.7
Description: {JavaNewCmd.cmdProc}
Test: {
set x [java::new {int[]} {} {0 1 2 3 4}]
list [$x get 0] [$x get 4]
}
Expected: {0 4}
Name: javaNewCmd-1.8
Description: {cmdProc}
Test: {
java::new {}
}
Expected: error {bad signature ""}
Name: javaNewCmd-1.9
Only: SpecialTestClasses
Description: {cmdProc}
Test: {
[java::new tests.JavaTest] imethod
}
Expected: 6
Name: javaNewCmd-1.10
Description: {cmdProc}
Test: {
java::new {int[]} {1 2 3} {1 2 3}
}
Expected: error {size list "1 2 3" doesn't match array dimension (1)}
Name: javaNewCmd-1.12
Description: {cmdProc}
Test: {
java::new {int[][]} {1 2 3} {1 2 3}
}
Expected: error {size list "1 2 3" doesn't match array dimension (2)}
Name: javaNewCmd-1.12
Description: {cmdProc}
Test: {
set a [java::new {int[][]} {2} {{11 22 33} {21 32 43}}]
$a getrange {0 0}
}
Expected: {11 22 33}
#
# ArraySig.looksLikeArraySig
#
Name: javaNewCmd-2.1
Description: {ArraySig.looksLikeArraySig}
Only: SpecialTestClasses
Test: {
set info ""
set m imethod
set x [java::new {tests.JavaTest String} foo]
$x $m
set info [jtest type $m]
list $info [catch {java::new $m} msg] $msg
}
Expected: {tcl.lang.TclList 1 {unknown class "imethod"}}
Name: javaNewCmd-2.2
Description: {ArraySig.looksLikeArraySig}
Only: SpecialTestClasses
Test: {
set info ""
set m {int[]}
set x [java::new $m 10]
set info [jtest type $m]
list $info [catch {java::new $m yyy} msg] $msg
}
Expected: {tcl.lang.ArraySig 1 {expected integer but got "yyy"}}
Name: javaNewCmd-2.3
Description: {ArraySig.looksLikeArraySig}
Test: {
java::new \{
}
Expected: error {unmatched open brace in list}
Name: javaNewCmd-2.4
Description: {ArraySig.looksLikeArraySig}
Test: {
java::new {blah blah blah}
}
Expected: error {unknown class "blah"}
#
# ArraySig.get
#
Name: javaNewCmd-3.1
Description: {ArraySig.get}
Only: SpecialTestClasses
Test: {
set m {int[]}
set x [java::new $m 10]
set robj [jtest getobject $m]
set internalRep [java::call tcl.lang.ArraySig get [java::getinterp] $robj]
set internalRep [java::cast tcl.lang.InternalRep $internalRep]
string compare [$robj getInternalRep] $internalRep
}
Expected: {0}
Name: javaNewCmd-3.2
Description: {ArraySig.get}
Only: SpecialTestClasses
Test: {
set m {int[]}
set robj [jtest getobject $m]
set internalRep [java::call tcl.lang.ArraySig get [java::getinterp] $robj]
[java::field $internalRep arrayType] getName
}
Expected: {[I}
Name: javaNewCmd-3.3
Description: {ArraySig.get}
Only: SpecialTestClasses
Test: {
set m {xyz}
set robj [jtest getobject $m]
java::call tcl.lang.ArraySig get [java::getinterp] $robj
}
Expected: error {bad array signature "xyz"}
Name: javaNewCmd-3.4
Description: {ArraySig.get}
Only: SpecialTestClasses
Test: {
set m "\{"
set robj [jtest getobject $m]
java::call tcl.lang.ArraySig get [java::getinterp] $robj
}
Expected: error {unmatched open brace in list}
Name: javaNewCmd-3.5
Description: {ArraySig.get}
Only: SpecialTestClasses
Test: {
set m {int[] a}
set robj [jtest getobject $m]
java::call tcl.lang.ArraySig get [java::getinterp] $robj
}
Expected: error {bad array signature "int[] a"}
Name: javaNewCmd-3.6
Description: {ArraySig.get}
Only: SpecialTestClasses
Test: {
set m {blah}
set robj [jtest getobject $m]
java::call tcl.lang.ArraySig get [java::getinterp] $robj
}
Expected: error {bad array signature "blah"}
Name: javaNewCmd-3.7
Description: {ArraySig.get}
Only: SpecialTestClasses
Test: {
set m {blah[]}
set robj [jtest getobject $m]
java::call tcl.lang.ArraySig get [java::getinterp] $robj
}
Expected: error {unknown class "blah"}
#
# Black-box tests
#
Name: javaNewCmd-4.1
Description: {java::new}
Only: SpecialTestClasses
Test: {
[java::new {tests.JavaTest String} foo] imethod
}
Expected: 6
Name: javaNewCmd-4.2
Description: {java::new}
Only: SpecialTestClasses
Test: {
[java::new {tests.JavaTest String int} foo 3] imethod
}
Expected: 6
Name: javaNewCmd-4.3
Description: {java::new}
Only: SpecialTestClasses
Test: {
[java::new {tests.JavaTest String int} foo 3] imethod
}
Expected: 6
Name: javaNewCmd-4.4
Description: {java::new: exception in constructor}
Only: SpecialTestClasses
Test: {
java::new {tests.JavaTest boolean} true
}
Expected: error {java.lang.NullPointerException}
Name: javaNewCmd-5.1
Description: {array case}
Test: {
set handle [java::new {int[]}]
}
Expected: error {wrong # args: should be "java::new int[] sizeList ?valueList?"}
Name: javaNewCmd-5.2
Description: {array case}
Test: {
set handle [java::new {int[]} 5 {6 7 8 9 10} junk]
}
Expected: error {wrong # args: should be "java::new int[] sizeList ?valueList?"}
Name: javaNewCmd-5.3
Description: {array case, no valueList}
Test: {
set handle [java::new {Integer[]} 5]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length]
}
Expected: {{java.lang.Integer[]} java.lang.Integer 1 5}
Name: javaNewCmd-5.4
Description: {array case, no valueList}
Test: {
set handle [java::new {Integer[][][]} {2 4 6}]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length]
}
Expected: {{java.lang.Integer[][][]} java.lang.Integer 3 2}
Name: javaNewCmd-5.5
Description: {array case, no valueList}
Only: SpecialTestClasses
Test: {
set handle [java::new {tests.javainfo.InfoTestClass[]} 4]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length]
}
Expected: {{tests.javainfo.InfoTestClass[]} tests.javainfo.InfoTestClass 1 4}
Name: javaNewCmd-5.6
Description: {array case, no valueList}
Only: SpecialTestClasses
Test: {
set handle [java::new {tests.javainfo.InfoTestClass[][][][]} {2 5 3 3}]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length]
}
Expected: {{tests.javainfo.InfoTestClass[][][][]} tests.javainfo.InfoTestClass 4 2}
Name: javaNewCmd-5.7
Description: {array case, no valueList}
Test: {
set handle [java::new {int[]} 5]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length]
}
Expected: {{int[]} int 1 5}
Name: javaNewCmd-5.8
Description: {array case, no valueList}
Test: {
set handle [java::new {int[][]} {3 3}]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length]
}
Expected: {{int[][]} int 2 3}
Name: javaNewCmd-5.9
Description: {array case, no valueList}
Test: {
set handle [java::new {int[][][]} 5]
}
Expected: error {cannot initialize a 3 dimensional array with zero size in dimension 1}
Name: javaNewCmd-5.10
Description: {array case, no valueList}
Test: {
set handle [java::new {int[][]} {4 6}]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length] \
[[$handle get 0] length]
}
Expected: {{int[][]} int 2 4 6}
Name: javaNewCmd-5.11
Description: {array case, empty sizeList}
Test: {
set handle [java::new {int[]} {}]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length]
}
Expected: {{int[]} int 1 0}
Name: javaNewCmd-5.12
Description: {array case, empty sizeList}
Test: {
set handle [java::new {int[]} {} {2 3 4 5}]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length] [$handle getrange]
}
Expected: {{int[]} int 1 4 {2 3 4 5}}
Name: javaNewCmd-5.13
Description: {array case, empty sizeList}
Test: {
set handle [java::new {int[][][]} {} {{{1 2} {3 4}} {{5 6} {7 8}}}]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length] [$handle getrange {0 1 0}]
}
Expected: {{int[][][]} int 3 2 {3 4}}
Name: javaNewCmd-5.14
Description: {array case, test classname}
Test: {
set handle [java::new {junk[][][]} {}]
}
Expected: error {unknown class "junk"}
Name: javaNewCmd-5.15
Description: {array case, test classname}
Test: {
set handle [java::new {[int} {}]
}
Expected: error {unknown class "[int"}
Name: javaNewCmd-5.16
Description: {array case, test classname}
Test: {
set handle [java::new {[int[][][]} {}]
}
Expected: error {unknown class "[int"}
Name: javaNewCmd-5.17
Description: {array case, test classname}
Test: {
set handle [java::new {[I} {}]
list [java::info cl $handle] [java::info ba $handle] \
[java::info di $handle] [$handle length]
}
Expected: {{int[]} int 1 0}
Name: javaNewCmd-6.0
Description: {static inner class}
Only: SpecialTestClasses
Test: {
# Allocate static inner class given the fully
# qualified name of the inner class.
set handle [java::new tests.InnerTest.InnerClass1]
java::info class $handle
}
Expected: {tests.InnerTest.InnerClass1}
Name: javaNewCmd-6.1
Description: {static inner class}
Only: SpecialTestClasses
Test: {
# Old method of passing fully qualified name containing a '$'
# is still supported even though it does not work very well.
set handle [java::new {tests.InnerTest$InnerClass1}]
java::info class $handle
}
Expected: {tests.InnerTest.InnerClass1}
Name: javaNewCmd-6.2
Description: {cast static inner class to inner Interface}
Only: SpecialTestClasses
Test: {
# Allocate a static inner class, then cast it to a
# static interface. This checks loading of both
# types via the fully qualified name.
set handle [java::new tests.InnerTest.InnerClass2]
set i [java::cast tests.InnerTest.InnerInterface1 $handle]
list [java::info class $handle] [java::info class $i]
}
Expected: {tests.InnerTest.InnerClass2 tests.InnerTest.InnerInterface1}
# Remove javaNewCmd-6.3 since JDK 1.5 compiler always raises an
# error when compiling an inner class with a name that is the
# same as a toplevel class. The runtime logic will always
# choose the toplevel class in this case.
Name: javaNewCmd-6.4
Description: {static inner class}
Only: SpecialTestClasses
Test: {
# Get handle to static inner class.
set c [java::field tests.InnerTest.InnerClass1 class]
$c toString
}
Expected: {class tests.InnerTest$InnerClass1}
Name: javaNewCmd-6.5
Description: {static array of inner class}
Only: SpecialTestClasses
Test: {
# Get handle to array of static inner class.
set c [java::new {tests.InnerTest.InnerClass1[]} {0}]
java::info class $c
}
Expected: {tests.InnerTest.InnerClass1[]}
Name: javaNewCmd-6.6
Description: {cast to inner interface}
Test: {
# Get handle to static inner interface
set c [java::field java.util.Map.Entry class]
$c toString
}
Expected: {interface java.util.Map$Entry}
Name: javaNewCmd-6.7
Description: {multiple inner classes}
Only: SpecialTestClasses
Test: {
# Get inner class inside inner class.
set o [java::call tests.InnerTest getInnerClass4]
java::info class $o
}
Expected: tests.InnerTest.InnerClass3.InnerClass4
Name: javaNewCmd-6.8
Description: {multiple inner classes}
Only: SpecialTestClasses
Test: {
# Use java::new to allocate inner class inside inner class.
# This checks that loading of inner classes works with
# multiple level of inner class names.
set o [java::new tests.InnerTest.InnerClass3.InnerClass4]
java::info class $o
}
Expected: {tests.InnerTest.InnerClass3.InnerClass4}
Name: javaNewCmd-6.9
Description: {multiple inner classes}
Only: SpecialTestClasses
Test: {
# Invoke Java methods that make use of imported
# inner classes.
list \
[java::info class [java::call tests.InnerImport newA]] \
[java::info class [java::call tests.InnerImport newB]] \
[java::info class [java::call tests.InnerImport newC]] \
[java::info class [java::call tests.InnerImport newD]] \
[java::info class [java::call tests.InnerImport newE]]
}
Expected: [list \
tests.InnerTest.InnerClass3 \
tests.InnerTest.InnerClass3 \
tests.InnerTest.InnerClass3.InnerClass4 \
tests.InnerTest.InnerClass3.InnerClass4 \
tests.InnerTest.InnerClass3.InnerClass4 \
]
Name: javaNewCmd-6.10
Description: {class in java.lang package}
Test: {
# Ref to class in java.lang
list \
[java::info class \
[java::cast java.lang.Character.Subset [java::null]]] \
[java::info class \
[java::cast Character.Subset [java::null]]] \
}
Expected: {java.lang.Character.Subset java.lang.Character.Subset}
# Test series 7 checks that primitive wrapper type
# constructors like Boolean, Integer, and others
# will make use of the overloaded constructor method
# that accepts a primitive type. A Tcl primitive
# should be converted to a Java primitive in
# these constructor invocations. The previous
# implementation would choose the overloaded
# constructor method that accepted a String,
# and Java string parsing rules did not match
# the Tcl semantics.
# The int parsing tests check the implementation
# of JavaInvoke.parseJavaInt(). This Java int parsing
# utility deals with int values defined by
# the Java range Integer.MIN_VALUE to Integer.MAX_VALUE.
# Tcl's integer parsing routines don't deal with
# signed 32bit integers correctly and can't be fixed
# without breaking backwards compatibility. Java
# long values are handled separately. Tests that
# make use of datatypes smaller than an int will
# parse as an integer and then check the valid range.
Name: javaNewCmd-7.0
Description: {parse Java type from String}
Test: {
list \
[[java::new Boolean true] toString] \
[[java::new Boolean false] toString] \
[[java::new Boolean 0x1] toString] \
[[java::new Boolean 0] toString] \
[[java::new Boolean 01] toString] \
[[java::new Boolean -0] toString] \
[[java::new java.lang.Boolean 0x1] toString]
}
Expected: {true false true false true false true}
Name: javaNewCmd-7.1
Description: {parse Java type from String}
Test: {
list \
[[java::new Integer -1] toString] \
[[java::new Integer 0] toString] \
[[java::new Integer 01] toString] \
[[java::new Integer 0x1] toString] \
[[java::new Integer " 0x1"] toString] \
[[java::new Integer "0x2 "] toString] \
[[java::new Integer " 01 "] toString] \
[[java::new Integer " 1 "] toString] \
[[java::new Integer "-0xAbCDeF"] toString]
}
Expected: {-1 0 1 1 1 2 1 1 -11259375}
Name: javaNewCmd-7.2
Description: {parse Java type from String}
Test: {
# Invalid int
list \
[catch {java::new Integer ""} err] $err \
[catch {java::new Integer " "} err] $err \
[catch {java::new Integer "-"} err] $err \
[catch {java::new Integer " -"} err] $err \
[catch {java::new Integer "- "} err] $err \
[catch {java::new Integer " - "} err] $err \
[catch {java::new Integer "0x"} err] $err \
[catch {java::new Integer " 0X "} err] $err \
[catch {java::new Integer "--1"} err] $err \
[catch {java::new Integer "-0xABCDEFG"} err] $err \
[catch {java::new Integer "A"} err] $err \
[catch {java::new Integer "-A"} err] $err \
[catch {java::new Integer "09"} err] $err \
}
Expected: [list \
1 {expected integer but got ""} \
1 {expected integer but got " "} \
1 {expected integer but got "-"} \
1 {expected integer but got " -"} \
1 {expected integer but got "- "} \
1 {expected integer but got " - "} \
1 {expected integer but got "0x"} \
1 {expected integer but got " 0X "} \
1 {expected integer but got "--1"} \
1 {expected integer but got "-0xABCDEFG"} \
1 {expected integer but got "A"} \
1 {expected integer but got "-A"} \
1 {expected integer but got "09"} \
]
Name: javaNewCmd-7.3
Description: {parse Java type from String}
Test: {
# int bounds
list \
[[java::new Integer -2147483648] toString] \
[[java::new Integer -0x80000000] toString] \
[catch {java::new Integer -2147483649} err] $err \
[catch {java::new Integer -0x80000001} err] $err \
[[java::new Integer 2147483647] toString] \
[[java::new Integer 0x7FFFFFFF] toString] \
[catch {java::new Integer 2147483648} err] $err \
[catch {java::new Integer 0x80000000} err] $err
}
Expected: [list \
-2147483648 \
-2147483648 \
1 {integer value too large to represent in a int} \
1 {integer value too large to represent in a int} \
2147483647 \
2147483647 \
1 {integer value too large to represent in a int} \
1 {integer value too large to represent in a int} \
]
Name: javaNewCmd-7.4
Description: {parse Java type from String}
Test: {
list \
[[java::new Byte -1] toString] \
[[java::new Byte 0] toString] \
[[java::new Byte 1] toString] \
[[java::new Byte 0x1] toString] \
[[java::new Byte 01] toString] \
}
Expected: {-1 0 1 1 1}
Name: javaNewCmd-7.5
Description: {parse Java type from String}
Test: {
# byte bounds, subset of int bounds
list \
[catch {java::new Byte 2147483648} err] $err \
[[java::new Byte -128] toString] \
[catch {java::new Byte -129} err] $err \
[[java::new Byte 127] toString] \
[catch {java::new Byte 128} err] $err
}
Expected: [list \
1 {integer value too large to represent in a int} \
-128 \
1 {integer value too large to represent in a byte} \
127 \
1 {integer value too large to represent in a byte} \
]
Name: javaNewCmd-7.6
Description: {parse Java type from String}
Test: {
list \
[[java::new Short -1] toString] \
[[java::new Short 0] toString] \
[[java::new Short 1] toString] \
[[java::new Short 0x1] toString] \
[[java::new Short 01] toString] \
}
Expected: {-1 0 1 1 1}
Name: javaNewCmd-7.7
Description: {parse Java type from String}
Test: {
# short bounds, subset of int bounds
list \
[catch {java::new Short 2147483648} err] $err \
[[java::new Short -32768] toString] \
[catch {java::new Short -32769} err] $err \
[[java::new Short 32767] toString] \
[catch {java::new Short 32768} err] $err
}
Expected: [list \
1 {integer value too large to represent in a int} \
-32768 \
1 {integer value too large to represent in a short} \
32767 \
1 {integer value too large to represent in a short} \
]
Name: javaNewCmd-7.8
Description: {parse Java type from String}
Test: {
list \
[[java::new Character a] toString] \
[[java::new Character b] toString] \
[[java::new Character \u0063] toString] \
[[java::new Character D] toString] \
[[java::new Character E] toString] \
[catch {java::new Character FG} err] $err
}
Expected: {a b c D E 1 {expected character but got "FG"}}
# Java long values are supported like int Java
# values, but they are parsed with Long.parseLong().
# Jacl can't handle 64 bit integers.
Name: javaNewCmd-7.9
Description: {parse Java type from String}
Test: {
list \
[[java::new Long -1] toString] \
[[java::new Long 0] toString] \
[[java::new Long 01] toString] \
[[java::new Long 0x1] toString] \
[[java::new Long " 0x1"] toString] \
[[java::new Long "0x2 "] toString] \
[[java::new Long " 01 "] toString] \
[[java::new Long " 1 "] toString] \
[[java::new Long "-0xAbCDeF"] toString]
}
Expected: {-1 0 1 1 1 2 1 1 -11259375}
Name: javaNewCmd-7.10
Description: {parse Java type from String}
Test: {
# Invalid long
list \
[catch {java::new Long ""} err] $err \
[catch {java::new Long " "} err] $err \
[catch {java::new Long "-"} err] $err \
[catch {java::new Long " -"} err] $err \
[catch {java::new Long "- "} err] $err \
[catch {java::new Long " - "} err] $err \
[catch {java::new Long "0x"} err] $err \
[catch {java::new Long " 0X "} err] $err \
[catch {java::new Long "--1"} err] $err \
[catch {java::new Long "-0xABCDEFG"} err] $err \
[catch {java::new Long "A"} err] $err \
[catch {java::new Long "-A"} err] $err \
[catch {java::new Long "09"} err] $err \
}
Expected: [list \
1 {expected integer but got ""} \
1 {expected integer but got " "} \
1 {expected integer but got "-"} \
1 {expected integer but got " -"} \
1 {expected integer but got "- "} \
1 {expected integer but got " - "} \
1 {expected integer but got "0x"} \
1 {expected integer but got " 0X "} \
1 {expected integer but got "--1"} \
1 {expected integer but got "-0xABCDEFG"} \
1 {expected integer but got "A"} \
1 {expected integer but got "-A"} \
1 {expected integer but got "09"} \
]
Name: javaNewCmd-7.11
Description: {parse Java type from String}
Test: {
# long bounds
list \
[[java::new Long -9223372036854775808] toString] \
[[java::new Long -0x8000000000000000] toString] \
[catch {java::new Long -9223372036854775809} err] $err \
[catch {java::new Long -0x8000000000000001} err] $err \
[[java::new Long 9223372036854775807] toString] \
[[java::new Long 0x7FFFFFFFFFFFFFFF] toString] \
[catch {java::new Long 9223372036854775808} err] $err \
[catch {java::new Long 0x8000000000000000} err] $err
}
Expected: [list \
-9223372036854775808 \
-9223372036854775808 \
1 {integer value too large to represent in a long} \
1 {integer value too large to represent in a long} \
9223372036854775807 \
9223372036854775807 \
1 {integer value too large to represent in a long} \
1 {integer value too large to represent in a long} \
]
# float bounds.
# Note that conversion of floating point numbers to
# strings in Tcl is problematic because of the
# default tcl_precision setting. See TIP 132 for info.
#
# http://www.tcl.tk/cgi-bin/tct/tip/132.html
# Float.MIN_VALUE
set min [java::field Float MIN_VALUE]
set smin 1.401298464324817e-046
# Float.MAX_VALUE
set max [java::field Float MAX_VALUE]
set bmax 3.4028234663852886e+039
set pmin 1.4E-45
set pmax 3.4028235E38
# Running expr operation changes the internal rep
# from TclDouble to a native double type and that
# seems to lose some precision and cause the test
# method to fail. Not sure how to approach this!
Name: javaNewCmd-7.12
Description: {parse Java type from String}
Test: {
list \
[[java::new Float 0.0] toString] \
[[java::new Float -0.0] toString] \
[[java::new Float Infinity] toString] \
[[java::new Float -Infinity] toString] \
[[java::new Float NaN] toString] \
[[java::new Float 10e-4] toString] \
[[java::new Float 10e8] toString] \
[[java::new Float $min] toString] \
[catch {java::new Float $smin} err] $err \
[[java::new Float $max] toString] \
[catch {java::new Float $bmax} err] $err
}
Expected: [list \
0.0 \
-0.0 \
Infinity \
-Infinity \
NaN \
0.001 \
1.0E9 \
$pmin \
1 {double value too large to represent in a float} \
$pmax \
1 {double value too large to represent in a float} \
]
Name: javaNewCmd-7.13
Description: {float stored in TclDouble}
Only: MathLimits
Test: {
# Float.MIN_VALUE stored in a TclDouble
# internal rep. Note that the Float.toString()
# method rounds to an invalid float when
# printing as a String.
set results [list]
set min [java::field Float MIN_VALUE]
lappend results [format %s $min]
set F [java::new Float $min]
lappend results [format %s [$F toString]]
lappend results [format %s [$F floatValue]]
set results
}
Expected: {1.40129846432e-045 1.4E-45 1.40129846432e-045}
Name: javaNewCmd-7.14
Description: {float stored in TclDouble}
Only: MathLimits
Test: {
# Printing a double in Java via
# StringBuffer.append(double) vs
# Util.printDouble(). This shows
# that Tcl is not printing all the
# needed bits in the floating point
# representation when the default
# tcl_precision of 12 is used.
set sb [java::new StringBuffer]
set min [java::field Float MIN_VALUE]
$sb {append double} $min
list \
[$sb toString] \
[format %s $min]
}
Expected: [list \
1.401298464324817E-45 \
1.40129846432e-045 \
]
Name: javaNewCmd-7.15
Description: {float stored in TclDouble - tip132}
Only: MathLimits
Test: {
# Printing the double value of Float.MIN_VALUE
# and then attempting to reparse from the
# string fails because of the default
# tcl_precision value of 12. This loss of
# precision is broken and needs to be fixed
# by implementing Tcl TIP 132 from Tcl 8.5.
# Applications need to work around this
# problem by setting tcl_precision to 17.
set results [list]
set min [java::field Float MIN_VALUE]
set min [format %s $min]
lappend results [format %s $min]
if {[catch {java::new Float $min} err]} {
lappend results ERROR $err
} else {
set F $err
lappend results [format %s [$F toString]]
lappend results [format %s [$F floatValue]]
}
set results
}
Expected: {1.40129846432e-045 1.4E-45 1.40129846432e-045}
Name: javaNewCmd-7.16
Description: {float stored in TclDouble}
Only: MathLimits
Test: {
# Parsing Float.MIN_VALUE as a String.
# This test is the same as the one above
# except that tcl_precision is upped to 16
# here so that the tests pass. This precision
# should really be 17 but that keeps
# the tests from passing under both Jacl and
# Tcl Blend because of differences in floating
# point handling in Jacl and sprintf().
set save_tcl_precision $tcl_precision
set tcl_precision 16
set results [list]
set min [java::field Float MIN_VALUE]
set min [format %s $min] ; # toss out TclDouble internal rep!
lappend results [format %s $min]
set F [java::new Float $min]
lappend results [format %s [$F toString]]
lappend results [format %s [$F floatValue]]
set tcl_precision $save_tcl_precision
set results
}
Expected: {1.401298464324817e-045 1.4E-45 1.401298464324817e-045}
Name: javaNewCmd-7.17
Description: {parse Java type from String}
Only: MathLimits
Test: {
# Float.MIN_VALUE stored in a TclDouble is
# then converted to a string rep and
# reparsed from the string by the expr.
# This test works in both Jacl and TclBlend
# because tcl_precision is change to 16.
set save_tcl_precision $tcl_precision
set tcl_precision 16
set results [list]
set min [java::field Float MIN_VALUE]
lappend results [format %s $min]
# In Tcl Blend, an expr will reparse the
# double from the string rep. The
# tcl_precision problem is triggered by
# the fact that the Tcl core can't make
# direct use of the double inside the
# Java object and it needs to convert
# to a Tcl double primitive from the string.
set min [expr {$min}]
lappend results [format %s $min]
# Create a Float object to test to see if the
# floating point is still equal to Float.MIN_VALUE.
if {[catch {java::new Float $min} err]} {
lappend results ERROR
lappend results $err
} else {
# No error
lappend results [format %s [$F toString]]
lappend results [format %s [$F floatValue]]
}
set tcl_precision $save_tcl_precision
set results
}
Expected: [list \
1.401298464324817e-045 \
1.401298464324817e-045 \
1.4E-45 \
1.401298464324817e-045 \
]
# double bounds
set min [java::field Double MIN_VALUE]
set max [java::field Double MAX_VALUE]
# FIXME: Tcl rolls small double values over to zero
set smin "5.0e-350"
set bmax "2.0e350"
set pmin 4.9E-324
set pmax 1.7976931348623157E308
Name: javaNewCmd-7.18
Description: {parse Java type from String}
Test: {
list \
[[java::new Double 0.0] toString] \
[[java::new Double -0.0] toString] \
[[java::new Double Infinity] toString] \
[[java::new Double -Infinity] toString] \
[[java::new Double NaN] toString] \
[[java::new Double 10e-4] toString] \
[[java::new Double 10e8] toString] \
[[java::new Double $min] toString] \
[[java::new Double $max] toString]
}
Expected: [list \
0.0 \
-0.0 \
Infinity \
-Infinity \
NaN \
0.001 \
1.0E9 \
$pmin \
$pmax \
]
# === cleanup ========================================
::tcltest::cleanupTests
return