# 2001 September 15 # # The author disclaims copyright to this source code. In place of # a legal notice, here is a blessing: # # May you do good and not evil. # May you find forgiveness for yourself and forgive others. # May you share freely, never taking more than you give. # #*********************************************************************** # This file implements regression tests for SQLite library. The # focus of this file is testing the sqlite4_num_*() interface. set testdir [file dirname $argv0] source $testdir/tester.tcl do_test num-1.1.1 { sqlite4_num_compare 20 20 } {equal} do_test num-1.1.2 { sqlite4_num_compare 20 2e1 } {equal} do_test num-1.1.3 { sqlite4_num_compare -00034 -3.4e1 } {equal} do_test num-1.1.4 { sqlite4_num_compare -inf +inf } {lesser} do_test num-1.1.5 { sqlite4_num_compare -inf 0 } {lesser} do_test num-1.1.6 { sqlite4_num_compare inf 4 } {greater} do_test num-1.1.7 { sqlite4_num_compare nan 7 } {incomparable} # Is +0 > -0? #do_test num-equal-1.1.4 { # sqlite4_num_compare +0 -0 #} {equal} do_test num-2.1.1 { sqlite4_num_to_text [sqlite4_num_from_text 37] } {37} do_test num-2.1.2 { sqlite4_num_to_text [sqlite4_num_from_text 37 2] } {37} do_test num-2.1.4 { sqlite4_num_compare [sqlite4_num_from_text 2.9e2X 5] 290 } {equal} do_test num-2.1.5 { sqlite4_num_isnan [sqlite4_num_from_text inf 2] } {true} do_test num-2.1.6 { sqlite4_num_isinf [sqlite4_num_from_text inf 3] } {true} do_test num-3.1.1 { sqlite4_num_to_text [sqlite4_num_add 5 7] } {12} foreach {tn a b difference} { 1 9 3 6 2 5 12 -7 3 -9 -10 1 4 -2 4 -6 5 -48 -48 0 6 NaN 4 NaN 7 95 NaN NaN 8 NaN inf NaN 9 inf inf NaN 10 -inf -inf NaN 11 inf -inf inf 12 -inf 955 -inf 13 -inf inf -inf } { do_test num-4.1.$tn { sqlite4_num_to_text [sqlite4_num_sub $a $b] } $difference } do_test num-4.2.1 { sqlite4_num_compare [sqlite4_num_sub 1 1] [sqlite4_num_sub -1 -1] } {equal} foreach {tn a b product} { 1 9 8 72 2 NaN inf NaN 3 inf NaN NaN 4 inf 0 NaN 5 inf -inf -inf 6 NaN 0 NaN 7 NaN 1 NaN 8 NaN -9 NaN 9 NaN NaN NaN } { do_test num-5.1.$tn { sqlite4_num_to_text [sqlite4_num_mul $a $b] } $product } foreach {tn a b product} { 1 1125899906842624 95367431640625 107374182400000000000000000000 1 95367431640625 1125899906842624 107374182400000000000000000000 2 40000000000 30000000000 1200000000000000000000 } { do_test num-5.2.$tn { sqlite4_num_compare [sqlite4_num_mul $a $b] $product } {equal} } # 5.2: Overflow that depends on the product of the two least # significant halves do_test num-5.2.1 { sqlite4_num_mul 3 6148914691236517211 } {sign:0 approx:1 e:1 m:1844674407370955163} do_test num-5.2.2 { sqlite4_num_mul 3 6148914690091192593 } {sign:0 approx:0 e:0 m:18446744070273577779} do_test num-6.1.1 { sqlite4_num_to_text [sqlite4_num_div 6 5] } {1.2} do_test num-6.1.2 { sqlite4_num_compare 2 [sqlite4_num_div 2 1] } {equal} do_test num-6.1.3 { sqlite4_num_to_text [sqlite4_num_div 2 1] } {2} do_test num-6.1.4 { sqlite4_num_to_text [sqlite4_num_div 22 10] } {2.2} #------------------------------------------------------------------------- # The following test cases - num-7.* - test the sqlite4_num_from_double() # API function. # foreach {tn in out} { 1 1.0 {sign:0 e:0 m:1} 2 -1.0 {sign:1 e:0 m:1} 3 1.5 {sign:0 e:-1 m:15} 4 -1.5 {sign:1 e:-1 m:15} 5 0.15 {sign:0 e:-2 m:15} 6 -0.15 {sign:1 e:-2 m:15} 7 45.345687 {sign:0 e:-6 m:45345687} 8 1000000000000000000 {sign:0 e:18 m:1} } { do_test num-7.1.$tn { set res [sqlite4_num_from_double $in] list [lindex $res 0] [lindex $res 2] [lindex $res 3] } [list [lindex $out 0] [lindex $out 1] [lindex $out 2]] } #------------------------------------------------------------------------- # Test the boundary conditions in sqlite4_num_from_text() for parsing # values that can fit in a signed 64-bit integer variable. And others. # foreach {tn in out} { 0 9223372036854775806 {sign:0 approx:0 e:0 m:9223372036854775806} 1 9223372036854775807 {sign:0 approx:0 e:0 m:9223372036854775807} 2 -9223372036854775808 {sign:1 approx:0 e:0 m:9223372036854775808} 3 -9223372036854775807 {sign:1 approx:0 e:0 m:9223372036854775807} 4 -9223372036854775806 {sign:1 approx:0 e:0 m:9223372036854775806} } { do_test num-8.1.$tn { sqlite4_num_from_text $in } $out } foreach {tn in out} { 0 9223372036854775808 {sign:0 approx:1 e:1 m:922337203685477581} 1 9223372036854775809 {sign:0 approx:1 e:1 m:922337203685477581} 2 9223372036854775810 {sign:0 approx:0 e:1 m:922337203685477581} 3 9223372036854775811 {sign:0 approx:1 e:1 m:922337203685477581} 4 -9223372036854775809 {sign:1 approx:1 e:1 m:922337203685477581} 5 -9223372036854775810 {sign:1 approx:0 e:1 m:922337203685477581} 6 -9223372036854775811 {sign:1 approx:1 e:1 m:922337203685477581} } { do_test num-8.2.$tn { sqlite4_num_from_text $in } $out } foreach {tn in out} { 0 2147483648 {sign:0 approx:0 e:0 m:2147483648} 1 -2147483648 {sign:1 approx:0 e:0 m:2147483648} } { do_test num-8.3.$tn { sqlite4_num_from_text $in } $out } #------------------------------------------------------------------------- # Test parsing of values with decimal points. # foreach {tn in out} { 0 1.5 {sign:0 approx:0 e:-1 m:15} 1 1.005 {sign:0 approx:0 e:-3 m:1005} 2 00000 {sign:0 approx:0 e:0 m:0} 3 00.000 {sign:0 approx:0 e:-3 m:0} 4 -1.005 {sign:1 approx:0 e:-3 m:1005} 5.1 1 {sign:0 approx:0 e:0 m:1} 5.2 1.0 {sign:0 approx:0 e:-1 m:10} 5.3 1. {sign:0 approx:0 e:0 m:1} 5.4 1e0 {sign:0 approx:0 e:0 m:1} 5.5 1e1 {sign:0 approx:0 e:1 m:1} 5.6 1e2 {sign:0 approx:0 e:2 m:1} } { do_test num-9.1.$tn { sqlite4_num_from_text $in } [list {*}$out] } #------------------------------------------------------------------------- # Test ignore-whitespace and prefix-only flags # foreach {tn in len flags out} { 0 {14 } -1 _ true 1 {14 } -1 w false 2 { 14 } -1 w false 3 {14 } 2 _ false 4 {14 } 3 _ true 5 {14abc} -1 _ true 6 {14abc} -1 p false 7 {+Inf } -1 p false 8 { 14 z} -1 w true 9 { 14 z} -1 wp false } { do_test num-9.2.$tn { sqlite4_num_isnan [sqlite4_num_from_text $in $len $flags] } $out } #------------------------------------------------------------------------- # Test from UTF16BE text # foreach {tn in len out} { 0 274 -1 274 1 3e+484 -1 3e+484 2 2e1 3 2 3 2e1 4 NaN 4 2e1 5 NaN 5 2e1 6 20 } { do_test num-9.3.$tn { sqlite4_num_to_text [sqlite4_num_from_text $in $len b] } $out } #------------------------------------------------------------------------- # Test from UTF16LE text # foreach {tn in len out} { 0 4639 -1 4639 1 5e+388 -1 5e+388 2 2e1 3 NaN 3 2e1 4 NaN 4 2e1 5 20 5 2e1 6 20 } { do_test num-9.4.$tn { sqlite4_num_to_text [sqlite4_num_from_text $in $len l] } $out } foreach {tn in out} { 0 50 50 1 -94 -94 2 {sign:0 approx:0 e:4 m:2} 20000 3 9223372036854775807 9223372036854775807 4 -9223372036854775808 -9223372036854775808 5 {sign:0 approx:0 e:-1 m:51} ~5 6 {sign:0 approx:0 e:0 m:9223372036854775808} ~9223372036854775807 7 9223372036854775808 ~9223372036854775807 8 10000000000000000000 ~9223372036854775807 9 -10000000000000000000 ~-9223372036854775808 10 {sign:0 approx:0 e:50 m:244} ~9223372036854775807 11 {sign:1 approx:0 e:50 m:34220} ~-9223372036854775808 12 50.1 ~50 13 10.9 ~10 14 .995 ~0 15 -93.9 ~-93 16 -12.1 ~-12 17 {sign:0 approx:1 e:0 m:4053} ~4053 } { do_test num-10.1.$tn { sqlite4_num_to_int64 $in } [list {*}$out] } foreach {tn in out} { 0 7093 7093 1 -98 -98 2 33.9 ~33 3 -438.4 ~-438 4 1e300 ~2147483647 5 -5000000000000 ~-2147483648 6 2147483647 2147483647 7 -2147483648 -2147483648 8 {sign:0 approx:1 e:4 m:2} ~20000 9 .00034 ~0 10 -.99 ~0 } { do_test num-11.1.$tn { sqlite4_num_to_int32 $in } [list {*}$out] } foreach {tn in real} { 0 4 false 1 -84.63 true 2 -Inf true } { do_test num-12.1-$tn { sqlite4_num_text_is_real $in } $real } #------------------------------------------------------------------------- finish_test