import strconv

/**********************************************************************
*
* String to float Test
*
**********************************************************************/

fn test_atof() {
	//
	// test set
	//

	// float64
	src_num := [
		f64(0.3),
		-0.3,
		0.004,
		-0.004,
		0.0,
		-0.0,
		31234567890123,
		0.01,
		2000,
		-300,
	]

	// strings
	src_num_str := [
		'0.3',
		'-0.3',
		'0.004',
		'-0.004',
		'0.0',
		'-0.0',
		'31234567890123',
		'1e-2',
		'+2e+3',
		'-3.0e+2',
	]

	// check conversion case 1 string <=> string
	for c, x in src_num {
		// slow atof
		val := strconv.atof64(src_num_str[c]) or { panic(err) }
		assert val.strlong() == x.strlong()

		// quick atof
		mut s1 := (strconv.atof_quick(src_num_str[c]).str())
		mut s2 := (x.str())
		delta := s1.f64() - s2.f64()
		// println("${s1} ${s2} ${delta}")
		assert delta < f64(1e-16)

		// test C.atof
		n1 := x.strsci(18)
		n2 := f64(C.atof(&char(src_num_str[c].str))).strsci(18)
		// println("${n1} ${n2}")
		assert n1 == n2
	}

	// check conversion case 2 string <==> f64
	// we don't test atof_quick because we already know the rounding error
	for c, x in src_num_str {
		b := src_num[c].strlong()
		value := strconv.atof64(x) or { panic(err) }
		a1 := value.strlong()
		assert a1 == b
	}

	// special cases
	mut f1 := f64(0.0)
	mut ptr := unsafe { &u64(&f1) }
	ptr = unsafe { &u64(&f1) }

	// double_plus_zero
	f1 = 0.0
	assert *ptr == u64(0x0000000000000000)
	// double_minus_zero
	f1 = -0.0
	assert *ptr == u64(0x8000000000000000)
	println('DONE!')
}

fn test_atof_subnormal() {
	// Test subnormal (denormalized) float numbers and edge cases
	// These are very small numbers close to the f64 minimum
	// IMPORTANT: Compare with hardcoded f64 literals, not .f64() which uses the same parser

	// Normal numbers
	assert strconv.atof64('1.0e-250') or { panic('parse error') } == 1.0e-250
	assert strconv.atof64('2.5e-260') or { panic('parse error') } == 2.5e-260

	// Transition zone
	assert strconv.atof64('1.0e-300') or { panic('parse error') } == 1.0e-300
	assert strconv.atof64('2.2250738585072014e-308') or { panic('parse error') } == 2.2250738585072014e-308

	// Subnormal numbers (these fail without the fix)
	assert strconv.atof64('1.23e-308') or { panic('parse error') } == 1.23e-308
	assert strconv.atof64('1.0e-310') or { panic('parse error') } == 1.0e-310
	assert strconv.atof64('5.0e-320') or { panic('parse error') } == 5.0e-320
	assert strconv.atof64('5e-324') or { panic('parse error') } == 5e-324

	// Negative subnormal
	assert strconv.atof64('-1.0e-320') or { panic('parse error') } == -1.0e-320
}

fn test_atof_small_decimal_with_many_leading_zeroes() {
	assert strconv.atof64('0.0000000000000000005') or { panic('parse error') } == strconv.atof64('5e-19') or {
		panic('parse error')
	}
	assert strconv.atof64('-0.0000000000000000005') or { panic('parse error') } == strconv.atof64('-5e-19') or {
		panic('parse error')
	}
}

fn test_atof_errors() {
	if x := strconv.atof64('') {
		eprintln('> x: ${x}')
		assert false // strconv.atof64 should have failed
	} else {
		assert err.str() == 'expected a number found an empty string'
	}
	if x := strconv.atof64('####') {
		eprintln('> x: ${x}')
		assert false // strconv.atof64 should have failed
	} else {
		assert err.str() == 'not a number'
	}
	if x := strconv.atof64('uu577.01') {
		eprintln('> x: ${x}')
		assert false // strconv.atof64 should have failed
	} else {
		assert err.str() == 'not a number'
	}
	if x := strconv.atof64('123.33xyz') {
		eprintln('> x: ${x}')
		assert false // strconv.atof64 should have failed
	} else {
		assert err.str() == 'extra char after number'
	}
}