note
	description: "[
		Eiffel tests that can be executed by testing tool.
	]"
	author: "EiffelStudio test wizard"
	date: "$Date$"
	revision: "$Revision$"
	testing: "type/manual"

class
	OCTAL_UTILS_TEST_SET

inherit
	EQA_TEST_SET

feature -- Test routines

	test_format_check
			-- Note test format checking features
		note
			testing:	"covers/{OCTAL_UTILS}.is_octal_natural_16_string"
			testing:	"covers/{OCTAL_UTILS}.is_octal_natural_32_string"
			testing:	"covers/{OCTAL_UTILS}.is_octal_natural_64_string"
		local
			unit_under_test: OCTAL_UTILS
			s: STRING
		do
			create unit_under_test

			-- Simple
			s := "12551"
			assert ("Basic format check (16bit)", unit_under_test.is_octal_natural_16_string (s))
			assert ("Basic format check (32bit)", unit_under_test.is_octal_natural_32_string (s))
			assert ("Basic format check (64bit)", unit_under_test.is_octal_natural_64_string (s))

			-- All zeros
			s := "0000000000000000000000000000000000000000000000000000000"
			assert ("All zeros format check (16bit)", unit_under_test.is_octal_natural_16_string (s))
			assert ("All zeros format check (32bit)", unit_under_test.is_octal_natural_32_string (s))
			assert ("All zeros format check (64bit)", unit_under_test.is_octal_natural_64_string (s))

			-- Max values
			assert ("Max 16bit format check", unit_under_test.is_octal_natural_16_string (octal_natural_16_max_value_string))
			assert ("Max 32bit format check", unit_under_test.is_octal_natural_32_string (octal_natural_32_max_value_string))
			assert ("Max 64bit format check", unit_under_test.is_octal_natural_64_string (octal_natural_64_max_value_string))

			-- Leading zero max values
			assert ("Leading zeros max 16bit format check", unit_under_test.is_octal_natural_16_string ("00000000000" + octal_natural_16_max_value_string))
			assert ("Leading zeros max 32bit format check", unit_under_test.is_octal_natural_32_string ("00000000000" + octal_natural_32_max_value_string))
			assert ("Leading zeros max 64bit format check", unit_under_test.is_octal_natural_64_string ("00000000000" + octal_natural_64_max_value_string))

			-- Negative number
			s := "-1"
			assert ("Reject negative number (16bit)", not unit_under_test.is_octal_natural_16_string (s))
			assert ("Reject negative number (32bit)", not unit_under_test.is_octal_natural_32_string (s))
			assert ("Reject negative number (64bit)", not unit_under_test.is_octal_natural_64_string (s))

			-- Too large number
			assert ("Reject too large (16bit)", not unit_under_test.is_octal_natural_16_string ("1" + octal_natural_16_max_value_string))
			assert ("Reject too large (32bit)", not unit_under_test.is_octal_natural_32_string ("1" + octal_natural_32_max_value_string))
			assert ("Reject too large (64bit)", not unit_under_test.is_octal_natural_64_string ("1" + octal_natural_64_max_value_string))

			-- Non-octal number
			s := "5327349"
			assert ("Reject non-octal number (16bit)", not unit_under_test.is_octal_natural_16_string (s))
			assert ("Reject non-octal number (32bit)", not unit_under_test.is_octal_natural_32_string (s))
			assert ("Reject non-octal number (64bit)", not unit_under_test.is_octal_natural_64_string (s))
		end

	test_parse
			-- Test parsing features
		note
			testing:	"covers/{OCTAL_UTILS}.octal_string_to_natural_16"
			testing:	"covers/{OCTAL_UTILS}.octal_string_to_natural_32"
			testing:	"covers/{OCTAL_UTILS}.octal_string_to_natural_64"
		local
			unit_under_test: OCTAL_UTILS
			s: STRING
		do
			create unit_under_test

			-- Basic functionality
			s := "141223"
			assert ("Basic parsing (16bit)", unit_under_test.octal_string_to_natural_16 (s) = 0c141223)
			assert ("Basic parsing (32bit)", unit_under_test.octal_string_to_natural_32 (s) = 0c141223)
			assert ("Basic parsing (64bit)", unit_under_test.octal_string_to_natural_64 (s) = 0c141223)

			s := "70365"
			assert ("Basic parsing 2 (16bit)", unit_under_test.octal_string_to_natural_16 (s) = 0c70365)
			assert ("Basic parsing 2 (32bit)", unit_under_test.octal_string_to_natural_32 (s) = 0c70365)
			assert ("Basic parsing 2 (64bit)", unit_under_test.octal_string_to_natural_64 (s) = 0c70365)

			-- Max values
			assert ("Max 16bit parsing", unit_under_test.octal_string_to_natural_16 (octal_natural_16_max_value_string) = {NATURAL_16}.max_value)
			assert ("Max 32bit parsing", unit_under_test.octal_string_to_natural_32 (octal_natural_32_max_value_string) = {NATURAL_32}.max_value)
			assert ("Max 64bit parsing", unit_under_test.octal_string_to_natural_64 (octal_natural_64_max_value_string) = {NATURAL_64}.max_value)

			-- All zeros
			s := "000000000000000"
			assert ("All zero parsing (16bit)", unit_under_test.octal_string_to_natural_16 (s) = 0)
			assert ("All zero parsing (32bit)", unit_under_test.octal_string_to_natural_32 (s) = 0)
			assert ("All zero parsing (64bit)", unit_under_test.octal_string_to_natural_64 (s) = 0)

			-- Leading zeros
			s := "0000000000000001"
			assert ("All zero parsing (16bit)", unit_under_test.octal_string_to_natural_16 (s) = 1)
			assert ("All zero parsing (32bit)", unit_under_test.octal_string_to_natural_32 (s) = 1)
			assert ("All zero parsing (64bit)", unit_under_test.octal_string_to_natural_64 (s) = 1)

			-- Leading zeros max values
			s := "00000000" + octal_natural_16_max_value_string
			assert ("Max 16bit parsing", unit_under_test.octal_string_to_natural_16 (s) = {NATURAL_16}.max_value)

			s := "00000000" + octal_natural_32_max_value_string
			assert ("Max 32bit parsing", unit_under_test.octal_string_to_natural_32 (s) = {NATURAL_32}.max_value)

			s := "0000000000000" +  octal_natural_64_max_value_string
			assert ("Max 64bit parsing", unit_under_test.octal_string_to_natural_64 (s) = {NATURAL_64}.max_value)
		end

	test_output
			-- Test printing features
		note
			testing:	"covers/{OCTAL_UTILS}.natural_16_to_octal_string"
			testing:	"covers/{OCTAL_UTILS}.natural_32_to_octal_string"
			testing:	"covers/{OCTAL_UTILS}.natural_64_to_octal_string"
		local
			unit_under_test: OCTAL_UTILS
			n16: NATURAL_16
			n32: NATURAL_32
			n64: NATURAL_64
		do
			create unit_under_test

			-- Basic functionality
			n16 := 0c12642
			assert ("Basic output (16bit)", unit_under_test.natural_16_to_octal_string (n16) ~ "12642")
			n32 := 0c34635231
			assert ("Basic output (32bit)", unit_under_test.natural_32_to_octal_string (n32) ~ "34635231")
			n64 := 0c1467623523
			assert ("Basic output (64bit)", unit_under_test.natural_64_to_octal_string (n64) ~ "1467623523")

			n16 := 0c12042
			assert ("Basic output 2 (16bit)", unit_under_test.natural_16_to_octal_string (n16) ~ "12042")
			n32 := 0c30635031
			assert ("Basic output 2 (32bit)", unit_under_test.natural_32_to_octal_string (n32) ~ "30635031")
			n64 := 0c1460023523
			assert ("Basic output 2 (64bit)", unit_under_test.natural_64_to_octal_string (n64) ~ "1460023523")

			-- Max values
			n16 := {NATURAL_16}.max_value
			assert ("Max 16bit output", unit_under_test.natural_16_to_octal_string (n16) ~ octal_natural_16_max_value_string)

			n32 := {NATURAL_32}.max_value
			assert ("Max 32bit output", unit_under_test.natural_32_to_octal_string (n32) ~ octal_natural_32_max_value_string)

			n64 := {NATURAL_64}.max_value
			assert ("Max 64bit output", unit_under_test.natural_64_to_octal_string (n64) ~ octal_natural_64_max_value_string)

			-- Zero
			n16 := 0
			assert ("Zero 16bit output", unit_under_test.natural_16_to_octal_string (n16) ~ "0")

			n32 := 0
			assert ("Zero 32bit output", unit_under_test.natural_32_to_octal_string (n32) ~ "0")

			n64 := 0
			assert ("Zero 64bit output", unit_under_test.natural_64_to_octal_string (n64) ~ "0")
		end

feature -- Utilities

	test_octal_conversion
			-- Test utility features
		note
			testing:	"covers/{OCTAL_UTILS}.natural_8_to_octal_character"
		local
			unit_under_test: OCTAL_UTILS
			i: NATURAL_8
		do
			-- Character conversion
			create unit_under_test
			from
				i := 0
			until
				i > 7
			loop
				assert ("Octal character conversion", i.out[1] = unit_under_test.natural_8_to_octal_character (i))
				i := i + 1
			end
		end

	test_leading_zeros
			-- Test leading zeros
		note
			testing:	"covers/{OCTAL_UTILS}.leading_zeros_count"
		local
			unit_under_test: OCTAL_UTILS
			i: NATURAL_8
			s: STRING
		do
			create unit_under_test
			-- -> all zeros
			from
				i := 1
			until
				i > 15
			loop
				s := "0"
				s.multiply (i)
				assert ("All leading zeros", unit_under_test.leading_zeros_count (s) = i - 1)
				i := i + 1
			end
			-- -> No leading zeros
			assert ("No leading zeros", unit_under_test.leading_zeros_count ("123456789") = 0)

			-- -> All zeros but last
			from
				i := 1
			until
				i > 15
			loop
				s := "0"
				s.multiply (i)
				s.append (i.out)
				assert ("Some leading zeros", unit_under_test.leading_zeros_count (s) = i)
				i := i + 1
			end

			-- -> Empty string
			assert ("Empty string", unit_under_test.leading_zeros_count ("") = 0)
		end

	test_pad
			-- Test padding
		note
			testing:	"covers/{OCTAL_UTILS}.pad"
		local
			unit_under_test: OCTAL_UTILS
			s: STRING
		do
			create unit_under_test
			s := "12345"
			unit_under_test.pad (s, 0)
			assert ("No padding", s ~ "12345")

			s := "12345"
			unit_under_test.pad (s, 5)
			assert ("Some padding", s ~ "0000012345")

			s := ""
			unit_under_test.pad (s, 1)
			assert ("Empty string", s ~ "0")
		end

	test_utility_combinations
			-- Test various combinations of the utility functions
		local
			unit_under_test: OCTAL_UTILS
			s: STRING
			i: INTEGER
		do
			create unit_under_test
			from
				i := 1
			until
				i > 16
			loop
				s := "123456789"
				unit_under_test.pad (s, i)
				assert ("Zeros added", unit_under_test.leading_zeros_count (s) = i)

				i := i + 1
			end
		end

feature {NONE} -- Constants

	octal_natural_16_max_value_string: STRING = "177777"
			-- {NATURAL_16}.max_value as octal string

	octal_natural_32_max_value_string: STRING = "37777777777"
			-- {NATURAL_32}.max_value as octal string

	octal_natural_64_max_value_string: STRING = "1777777777777777777777"
			-- {NATURAL_64}.max_value as octal string
end