note
	description: "[
		Testing suite for the BIG_INTEGER Class covering the operation capabilities
		on very large numbers.
	]"
	author: "JSO & CD"
	date: "June 6 2019"
	revision: "1.00"

class 
	INT_LONG_TEST

create 
	make

feature {NONE} -- Initialization

	default_create
			-- Process instances of classes with no creation clause.
			-- (Default: do nothing.)
			-- (from ANY)
		do
		end

	make
		do
			create i1.make_from_string ("75843729058432099845623987849785843902885094382")
			create i2.make_from_string ("4535438549854903278504932073290054372504865743")
			create answer.default_create
			add_boolean_case (agent t1)
			add_boolean_case (agent t2)
			add_boolean_case (agent t3)
			add_boolean_case (agent t4)
			add_boolean_case (agent t5)
			add_boolean_case (agent t6)
			add_boolean_case (agent t7)
			add_boolean_case (agent t8)
			add_boolean_case (agent t9)
			add_boolean_case (agent t10)
			add_boolean_case (agent t50)
			add_boolean_case (agent t51)
		end
	
feature {NONE} -- Access

	Execution_environment: EXECUTION_ENVIRONMENT
			-- An execution environment object.
			-- (from SHARED_EXECUTION_ENVIRONMENT)
		once
			create Result
		end
	
feature -- Access

	generating_type: TYPE [detachable INT_LONG_TEST]
			-- Type of current object
			-- (type of which it is a direct instance)
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			generating_type_not_void: Result /= Void
		end

	generator: STRING_8
			-- Name of current object's generating class
			-- (base class of the type of which it is a direct instance)
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			generator_not_void: Result /= Void
			generator_not_empty: not Result.is_empty
		end
	
feature -- Comparison

	frozen deep_equal (a: detachable ANY; b: like arg #1): BOOLEAN
			-- Are a and b either both void
			-- or attached to isomorphic object structures?
			-- (from ANY)
		do
			if a = Void then
				Result := b = Void
			else
				Result := b /= Void and then a.is_deep_equal (b)
			end
		ensure -- from ANY
			instance_free: class
			shallow_implies_deep: standard_equal (a, b) implies Result
			both_or_none_void: (a = Void) implies (Result = (b = Void))
			same_type: (Result and (a /= Void)) implies (b /= Void and then a.same_type (b))
			symmetric: Result implies deep_equal (b, a)
		end

	frozen equal (a: detachable ANY; b: like arg #1): BOOLEAN
			-- Are a and b either both void or attached
			-- to objects considered equal?
			-- (from ANY)
		do
			if a = Void then
				Result := b = Void
			else
				Result := b /= Void and then a.is_equal (b)
			end
		ensure -- from ANY
			instance_free: class
			definition: Result = (a = Void and b = Void) or else ((a /= Void and b /= Void) and then a.is_equal (b))
		end

	frozen is_deep_equal (other: INT_LONG_TEST): BOOLEAN
			-- Are Current and other attached to isomorphic object structures?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			shallow_implies_deep: standard_is_equal (other) implies Result
			same_type: Result implies same_type (other)
			symmetric: Result implies other.is_deep_equal (Current)
		end

	is_equal (other: INT_LONG_TEST): BOOLEAN
			-- Is other attached to an object considered
			-- equal to current object?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			symmetric: Result implies other ~ Current
			consistent: standard_is_equal (other) implies Result
		end

	frozen standard_equal (a: detachable ANY; b: like arg #1): BOOLEAN
			-- Are a and b either both void or attached to
			-- field-by-field identical objects of the same type?
			-- Always uses default object comparison criterion.
			-- (from ANY)
		do
			if a = Void then
				Result := b = Void
			else
				Result := b /= Void and then a.standard_is_equal (b)
			end
		ensure -- from ANY
			instance_free: class
			definition: Result = (a = Void and b = Void) or else ((a /= Void and b /= Void) and then a.standard_is_equal (b))
		end

	frozen standard_is_equal (other: INT_LONG_TEST): BOOLEAN
			-- Is other attached to an object of the same type
			-- as current object, and field-by-field identical to it?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			same_type: Result implies same_type (other)
			symmetric: Result implies other.standard_is_equal (Current)
		end
	
feature -- Status report

	conforms_to (other: ANY): BOOLEAN
			-- Does type of current object conform to type
			-- of other (as per Eiffel: The Language, chapter 13)?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		end

	same_type (other: ANY): BOOLEAN
			-- Is type of current object identical to type of other?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			definition: Result = (conforms_to (other) and other.conforms_to (Current))
		end
	
feature -- Duplication

	frozen clone (other: detachable ANY): like other
		obsolete "Use `twin' instead. [2017-05-31]"
			-- Void if other is void; otherwise new object
			-- equal to other
			--
			-- For non-void other, clone calls copy;
			-- to change copying/cloning semantics, redefine copy.
			-- (from ANY)
		do
			if other /= Void then
				Result := other.twin
			end
		ensure -- from ANY
			instance_free: class
			equal: Result ~ other
		end

	copy (other: INT_LONG_TEST)
			-- Update current object using fields of object attached
			-- to other, so as to yield equal objects.
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
			type_identity: same_type (other)
		external
			"built_in"
		ensure -- from ANY
			is_equal: Current ~ other
		end

	frozen deep_clone (other: detachable ANY): like other
		obsolete "Use `deep_twin' instead. [2017-05-31]"
			-- Void if other is void: otherwise, new object structure
			-- recursively duplicated from the one attached to other
			-- (from ANY)
		do
			if other /= Void then
				Result := other.deep_twin
			end
		ensure -- from ANY
			instance_free: class
			deep_equal: deep_equal (other, Result)
		end

	frozen deep_copy (other: INT_LONG_TEST)
			-- Effect equivalent to that of:
			--		copy (other . deep_twin)
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		do
			copy (other.deep_twin)
		ensure -- from ANY
			deep_equal: deep_equal (Current, other)
		end

	frozen deep_twin: INT_LONG_TEST
			-- New object structure recursively duplicated from Current.
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			deep_twin_not_void: Result /= Void
			deep_equal: deep_equal (Current, Result)
		end

	frozen standard_clone (other: detachable ANY): like other
		obsolete "Use `standard_twin' instead. [2017-05-31]"
			-- Void if other is void; otherwise new object
			-- field-by-field identical to other.
			-- Always uses default copying semantics.
			-- (from ANY)
		do
			if other /= Void then
				Result := other.standard_twin
			end
		ensure -- from ANY
			instance_free: class
			equal: standard_equal (Result, other)
		end

	frozen standard_copy (other: INT_LONG_TEST)
			-- Copy every field of other onto corresponding field
			-- of current object.
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
			type_identity: same_type (other)
		external
			"built_in"
		ensure -- from ANY
			is_standard_equal: standard_is_equal (other)
		end

	frozen standard_twin: INT_LONG_TEST
			-- New object field-by-field identical to other.
			-- Always uses default copying semantics.
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			standard_twin_not_void: Result /= Void
			equal: standard_equal (Result, Current)
		end

	frozen twin: INT_LONG_TEST
			-- New object equal to Current
			-- twin calls copy; to change copying/twinning semantics, redefine copy.
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			twin_not_void: Result /= Void
			is_equal: Result ~ Current
		end
	
feature -- Basic operations

	add_boolean_case (v: PREDICATE)
			-- Add boolean function v.
			-- (from ES_TEST)
		require -- from ES_TEST
			v_valid: v /= Void
		do
			if cases = Void then
				initialize
			end
			if attached cases as cases1 then
				cases1.extend (create {ES_BOOLEAN_TEST_CASE}.make ("", v))
			end
		end

	add_violation_case (v: PROCEDURE)
			-- Add boolean function v.
			-- (from ES_TEST)
		require -- from ES_TEST
			v_valid: v /= Void
		do
			if cases = Void then
				initialize
			end
			if attached cases as cases1 then
				cases1.extend (create {ES_VIOLATION_CASE}.make ("", v))
			end
		end

	add_violation_case_with_tag (expected_tag: STRING_8; v: PROCEDURE)
			-- Add boolean function v.
			-- (from ES_TEST)
		require -- from ES_TEST
			v_valid: v /= Void
		do
			if cases = Void then
				initialize
			end
			if attached cases as cases1 then
				cases1.extend (create {ES_VIOLATION_CASE}.make_with_tag ("", v, expected_tag))
			end
		end

	frozen as_attached: attached INT_LONG_TEST
		obsolete "Remove calls to this feature. [2017-05-31]"
			-- Attached version of Current.
			-- (Can be used during transitional period to convert
			-- non-void-safe classes to void-safe ones.)
			-- (from ANY)
		do
			Result := Current
		end

	frozen default: detachable INT_LONG_TEST
			-- Default value of object's type
			-- (from ANY)
		do
		end

	frozen default_pointer: POINTER
			-- Default value of type POINTER
			-- (Avoid the need to write p.default for
			-- some p of type POINTER.)
			-- (from ANY)
		do
		ensure -- from ANY
			instance_free: class
		end

	default_rescue
			-- Process exception for routines with no Rescue clause.
			-- (Default: do nothing.)
			-- (from ANY)
		do
		end

	frozen do_nothing
			-- Execute a null action.
			-- (from ANY)
		do
		ensure -- from ANY
			instance_free: class
		end
	
feature {ES_SUITE} 

	case_name: STRING_8
			-- (from ES_TEST)
		attribute
			Result := ""
		end

	count: INTEGER_32
			-- Number of test cases in Current.
			-- (from ES_TEST)
		do
			check
					attached cases as cases1
			then
				Result := cases1.count
			end
		end

	create_case_name (case: ES_TEST_CASE; unkn: CELL [INTEGER_32])
			-- (from ES_TEST)
		local
			ls: LIST [STRING_8]
		do
			ls := case.case_name.split (':'.to_character_32)
			if not case.case_name.has (':') or ls.is_empty then
				unkn.put (unkn.item + 1)
				case_name := "unknown_" + unkn.item.out + " -- use ':' in a `comment' in the test case"
			else
				case_name := ls.first
			end
			if attached name as n then
				case_name := n + "." + case_name
			end
		end

	failed_cases: LIST [STRING_8]
			-- List of the name of all the failed test cases.
			-- (from ES_TEST)
		local
			failed: ARRAYED_LIST [STRING_8]
			unkn: CELL [INTEGER_32]
		do
			create failed.make (10)
			create unkn.put (0)
			if attached cases as cases1 then
				across
					cases1 as it
				loop
					create_case_name (it.item, unkn)
					if not it.item.passed then
						failed.extend (case_name)
					end
				end
			end
			Result := failed
		end

	get_test_name: STRING_8
			-- Get unit test name.
			-- (from ES_TEST)
		do
			if name /= Void then
				check
						attached name as n
				then
					Result := n
				end
			else
				Result := "default_name"
			end
		end

	initialize
			-- Initialize Current.
			-- (from ES_TEST)
		do
			create cases.make
			name := generating_type.name.as_string_8
			create descriptions.make
		end

	passed_cases: LIST [STRING_8]
			-- List of the name of all the successful test cases.
			-- (from ES_TEST)
		local
			success: ARRAYED_LIST [STRING_8]
			unkn: CELL [INTEGER_32]
		do
			create success.make (10)
			create unkn.put (0)
			if attached cases as cases1 then
				across
					cases1 as it
				loop
					create_case_name (it.item, unkn)
					if it.item.passed then
						success.extend (case_name)
					end
				end
			end
			Result := success
		end

	run_es_test
			-- Run tests in cases.
			-- (from ES_TEST)
		local
			problem: BOOLEAN
			last_index: INTEGER_32
		do
			if attached cases as cases1 then
				if not problem then
					number_of_tests := 0
					number_passed_tests := 0
					check
							attached get_test_name as test_name
					then
						safe_put_string (test_name + "%N")
					end
				else
					safe_put_string ("***FAILED                   Problem in 'setup' or 'teardown' features%N")
					if show_err then
						check
								attached cases1.item as item1
								attached item1.exception_trace as et
						then
							safe_put_string ("%N" + et + "%N")
						end
					end
				end
				from
					if not problem then
						cases1.start
					else
						if cases1.valid_cursor_index (last_index) then
							cases1.go_i_th (last_index)
						end
					end
				until
					cases1.after
				loop
					class_variable_comment_string := "no comment"
					setup
					check
							attached cases1.item as item1
					then
						item1.run
						teardown
						check
								attached class_variable_comment_string as cvc
						then
							item1.set_case_name (cvc)
						end
						check
								attached to_message_string (item1) as ms
						then
							safe_put_string (ms + "%N")
						end
						number_of_tests := number_of_tests + 1
						if item1.passed then
							number_passed_tests := number_passed_tests + 1
						end
					end
					cases1.forth
				end
			end
			to_html (get_html_name)
			check_browser
		rescue
			check
					attached cases as cases1
			then
				problem := True
				cases1.forth
				last_index := cases1.index
				retry
			end
		end

	to_html (output_file_name: STRING_8)
			-- Generate HTML report with details.
			-- (from ES_TEST)
		require -- from ES_TEST
			output_file_name_valid: output_file_name /= Void
		local
			gen: ES_SUITE
		do
			create gen
			gen.add_test (Current)
			gen.pass_values (show_err, browser, name)
			gen.to_html (output_file_name)
		end

	to_message_string (item: ES_TEST_CASE): STRING_8
			-- Text represenation of a test case.
			-- (from ES_TEST)
		require -- from ES_TEST
			arg_not_void: item /= Void
		do
			check
					attached cases as cases1
			then
				create Result.make_empty
				if item.passed then
					Result.append_string ("   PASSED   ")
				else
					Result.append_string ("***FAILED   ")
				end
				check
						attached cases1.item as item1
				then
					if item.contract_violated then
						check
								attached item1.meaning (item1.violation_type) as meaning
						then
							Result.append_string ("VIOL      " + "#" + meaning + "#")
						end
					else
						Result.append_string ("NO VIOL   ")
					end
					Result.append_string (item1.case_name)
					if show_err then
						check
								attached item1.violation_tag as tag
						then
							Result.append_string ("%N" + tag)
						end
					end
				end
			end
		ensure -- from ES_TEST
			result_not_void: Result /= Void
			result_not_empty: not Result.is_empty
		end
	
feature 

	browser: BOOLEAN
			-- (from ES_TESTABLE)

	check_browser
			-- Run the browser on the generated HTML.
			-- (from ES_TESTABLE)
		do
			check
					attached get_html_name
			end
			if browser then
				if {PLATFORM}.is_windows then
					Execution_environment.launch ("%"explorer%" " + get_html_name + "%"")
				elseif {PLATFORM}.is_mac then
					Execution_environment.launch ("open" + " '" + get_html_name + "'")
				else
					check
							{PLATFORM}.is_unix
					end
					Execution_environment.launch ("xdg-open" + " '" + get_html_name + "'")
				end
			end
		end

	curr_os_dir_separator: CHARACTER_8
			--  Return path separator for current OS.
			-- (from ES_TESTABLE)
		do
			Result := (create {OPERATING_ENVIRONMENT}).Directory_separator
		ensure -- from ES_TESTABLE
			separator_is_a_slash: Result = '/' or Result = '\'
		end

	default_html_name: detachable STRING_8
			-- (from ES_TESTABLE)

	get_html_name: STRING_8
			-- Return the name of the default html for this unit test.
			-- (from ES_TESTABLE)
		do
			if default_html_name /= Void then
				check
						attached default_html_name as d
				then
					Result := d.twin
				end
			else
				Result := (generating_type.name + ".html").as_string_8
			end
		end

	number_of_tests: INTEGER_32
			-- (from ES_TESTABLE)

	number_passed_tests: INTEGER_32
			-- (from ES_TESTABLE)

	print_console_report
			-- Print a summary of all the test case results to the console.
			-- (from ES_TESTABLE)
		local
			failed: LIST [STRING_8]
			success: LIST [STRING_8]
			passed, total: INTEGER_32
		do
			failed := failed_cases
			success := passed_cases
			passed := success.count
			total := success.count + failed.count
			Io.put_string (create {STRING_8}.make_filled ('=', 60))
			Io.put_new_line
			safe_put_string ("passing tests%N")
			across
				success as it
			loop
				safe_put_string ("> " + it.item + "%N")
			end
			safe_put_string ("failing tests%N")
			across
				failed as it
			loop
				safe_put_string ("> " + it.item + "%N")
			end
			safe_put_string (passed.out + "/" + total.out + " passed%N")
			if number_of_tests = number_passed_tests then
				safe_put_string ("passed%N")
			else
				safe_put_string ("failed%N")
			end
		end

	print_to_screen (message: STRING_8)
			-- Prints the message to the screen, handles both GUI and standard output.
			-- (from ES_TESTABLE)
		do
			safe_put_string (message)
		end

	run_espec
			-- New feature instead of run_all.
			-- (from ES_TESTABLE)
		local
			problem: BOOLEAN
		do
			if not problem then
				run_es_test
				print_console_report
			end
		rescue
			problem := True
			print_to_screen ("Error: No test cases found, Please add ES_TEST classes to the class that inherits from ES_SUITE%N")
			retry
		end

	safe_put_string (message: STRING_8)
			-- Socket.putstring with exception handling.
			-- (from ES_TESTABLE)
		do
			print (message)
		end

	set_error_report (v: BOOLEAN)
			-- Show the contract violations if set to true.
			-- (from ES_TESTABLE)
		do
			show_err := v
		end

	set_html_name (s: STRING_8)
			-- Set the output html name.
			-- (from ES_TESTABLE)
		do
			default_html_name := s
		end

	show_browser
			-- Show the default browser.
			-- (from ES_TESTABLE)
		do
			browser := True
		end

	show_err: BOOLEAN
			-- (from ES_TESTABLE)

	show_errors
			-- Print error traces to the output.
			-- (from ES_TESTABLE)
		do
			show_err := True
		end
	
feature -- Attributes

	answer: BIG_INTEGER

	i1: BIG_INTEGER

	i2: BIG_INTEGER
	
feature -- Output

	Io: STD_FILES
			-- Handle to standard file setup
			-- (from ANY)
		once
			create Result
			Result.set_output_default
		ensure -- from ANY
			instance_free: class
			io_not_void: Result /= Void
		end

	out: STRING_8
			-- New string containing terse printable representation
			-- of current object
			-- (from ANY)
		do
			Result := tagged_out
		ensure -- from ANY
			out_not_void: Result /= Void
		end

	print (o: detachable ANY)
			-- Write terse external representation of o
			-- on standard output.
			-- (from ANY)
		do
			if o /= Void then
				Io.put_string (o.out)
			end
		ensure -- from ANY
			instance_free: class
		end

	frozen tagged_out: STRING_8
			-- New string containing terse printable representation
			-- of current object
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			tagged_out_not_void: Result /= Void
		end
	
feature -- Platform

	Operating_environment: OPERATING_ENVIRONMENT
			-- Objects available from the operating system
			-- (from ANY)
		once
			create Result
		ensure -- from ANY
			instance_free: class
			operating_environment_not_void: Result /= Void
		end
	
feature {NONE} -- Retrieval

	frozen internal_correct_mismatch
			-- Called from runtime to perform a proper dynamic dispatch on correct_mismatch
			-- from MISMATCH_CORRECTOR.
			-- (from ANY)
		local
			l_msg: STRING_8
			l_exc: EXCEPTIONS
		do
			if attached {MISMATCH_CORRECTOR} Current as l_corrector then
				l_corrector.correct_mismatch
			else
				create l_msg.make_from_string ("Mismatch: ")
				create l_exc
				l_msg.append (generating_type.name)
				l_exc.raise_retrieval_exception (l_msg)
			end
		end
	
feature -- Tests

	t1: BOOLEAN
		do
			comment ("t1: Addition - Very Large Integers")
			answer := create {BIG_INTEGER}.make_from_string ("80379167608287003124128919923075898275389960125")
			Result := i1 + i2 ~ answer
			check
					Result
			end
			Result := i1 + i2 ~ create {BIG_INTEGER}.make_from_string ("80379167608287003124128919923075898275389960125")
			check
					Result
			end
			Result := (i1 + i2).out ~ "80379167608287003124128919923075898275389960125"
			check
					Result
			end
		end

	t10: BOOLEAN
		local
			i: BIG_INTEGER
		do
			comment ("t10: make and is_equal - Very Large Integers")
			create i.make_from_string ("9223372036854775808000000000000")
			check
					i.out ~ "9223372036854775808000000000000" and i ~ create {BIG_INTEGER}.make_from_string ("9223372036854775808000000000000")
			end
			create i.make_from_string ("9223372036854775808000000000001")
			check
					i.out ~ "9223372036854775808000000000001" and i ~ create {BIG_INTEGER}.make_from_string ("9223372036854775808000000000001")
			end
			create i.make_from_string ("0009223372036854775808000000000001")
			check
					i.out ~ "9223372036854775808000000000001" and i ~ create {BIG_INTEGER}.make_from_string ("9223372036854775808000000000001")
			end
			create i.make_from_string ("-0009223372036854775808000000000001")
			check
					i.out ~ "-9223372036854775808000000000001" and i ~ create {BIG_INTEGER}.make_from_string ("-9223372036854775808000000000001")
			end
			Result := i ~ create {BIG_INTEGER}.make_from_string ("-00000000009223372036854775808000000000001")
		end

	t2: BOOLEAN
		do
			comment ("t2: Subtraction - Very Large Integers")
			answer := create {BIG_INTEGER}.make_from_string ("71308290508577196567119055776495789530380228639")
			Result := i1 - i2 ~ answer
			check
					Result
			end
			Result := i1 - i2 ~ create {BIG_INTEGER}.make_from_string ("71308290508577196567119055776495789530380228639")
			check
					Result
			end
			Result := (i1 - i2).out ~ "71308290508577196567119055776495789530380228639"
			check
					Result
			end
			answer := create {BIG_INTEGER}.make_from_string ("-71308290508577196567119055776495789530380228639")
			Result := i2 - i1 ~ answer
			check
					Result
			end
			Result := i2 - i1 ~ create {BIG_INTEGER}.make_from_string ("-71308290508577196567119055776495789530380228639")
			check
					Result
			end
			Result := (i2 - i1).out ~ "-71308290508577196567119055776495789530380228639"
			check
					Result
			end
		end

	t3: BOOLEAN
			-- Multiplication
		do
			comment ("t3: Multiplication - Very Large Integers")
			answer := create {BIG_INTEGER}.make_from_string ("343984572536363471764953370510996842545122233740057866577965768795250381398043841122793555826")
			Result := i1 * i2 ~ answer
			check
					Result
			end
			Result := i1 * i2 ~ create {BIG_INTEGER}.make_from_string ("343984572536363471764953370510996842545122233740057866577965768795250381398043841122793555826")
		end

	t4: BOOLEAN
			-- Division
		do
			comment ("t4: Division - Very Large Integers")
			answer := create {BIG_INTEGER}.make_from_string ("16")
			Result := i1 // i2 ~ answer
			check
					Result
			end
		end

	t5: BOOLEAN
			-- Power
		do
			comment ("t5: Power - Very Large Integers")
			answer := create {BIG_INTEGER}.make_from_string ("190334742364607652155107336189619557300746150258796951555022653630312334631543560605738075562813964210570753927595368814050317457233837391456768083319983219297294285812519379516050328960013136910960459963768346105403116172781874416655835066868587540203304953006545312601677853097024")
			Result := i1.power (6) ~ answer
			check
					Result
			end
			assert_equal ("fail", (i1.power (6)).out, "190334742364607652155107336189619557300746150258796951555022653630312334631543560605738075562813964210570753927595368814050317457233837391456768083319983219297294285812519379516050328960013136910960459963768346105403116172781874416655835066868587540203304953006545312601677853097024")
		end

	t6: BOOLEAN
			-- Square
		do
			comment ("t6: Square - Very Large Integers")
			answer := create {BIG_INTEGER}.make_from_string ("5752271237488857694599205433125871370720334779334273953877384762094874006286361709193047961924")
			Result := i1.square ~ answer
		end

	t7: BOOLEAN
			-- Remainder
		do
			comment ("t7: Remainder - Very Large Integers")
			answer := create {BIG_INTEGER}.make_from_string ("3276712260753647389545074677144973942807242494")
			Result := i1 \\ i2 ~ answer
			check
					Result
			end
			answer := create {BIG_INTEGER}.make_from_string ("4535438549854903278504932073290054372504865743")
			Result := i2 \\ i1 ~ answer
			check
					Result
			end
		end

	t8: BOOLEAN
			-- GCD
		local
			i3: BIG_INTEGER
		do
			comment ("t8: GCD - Very Large Integers")
			i3 := create {attached BIG_INTEGER}.make_from_string ("37921864529216049922811993924892921951442547191")
			answer := create {BIG_INTEGER}.make_from_string ("37921864529216049922811993924892921951442547191")
			Result := i1.gcd (i3) ~ answer
		end

	t9: BOOLEAN
			-- is_string_int
		local
		do
			comment ("t9: is_string_int - Very Large Integers")
			Result := not i1.is_string_int ("467128642831764315739215904321564239564789+5436218975017540728548726584901709574312075483912574354325432")
			check
					Result
			end
			Result := i1.is_string_int ("4671286428317643157392159043215642395647895189473129057423189056271876548971205948319058436789")
			check
					Result
			end
			Result := i1.is_string_int ("000000000000000000000000000000000000004671286428317643157392159043215642395647895189473129057423189056271876548971205948319058436789")
			check
					Result
			end
			Result := i1.is_string_int ("-4671286428317643157392159043215642395647895189473129057423189056271876548971205948319058436789")
			check
					Result
			end
			Result := i1.is_string_int ("-000000000000000000000000000000000000004671286428317643157392159043215642395647895189473129057423189056271876548971205948319058436789")
			check
					Result
			end
			Result := not i1.is_string_int ("+000000000000000000000000000000000000004671286428317643157392159043215642395647895189473129057423189056271876548971205948319058436789")
			check
					Result
			end
			Result := not i1.is_string_int ("00-000000000000000000000000000000000000004671286428317643157392159043215642395647895189473129057423189056271876548971205948319058436789")
			check
					Result
			end
		end
	
feature {NONE} -- setup and teardown

	assert (a_name: STRING_8; condition: BOOLEAN; actual: detachable ANY)
			-- (from ES_TEST)
		local
			l_line1, l_line2: attached STRING_8
			actual_out: STRING_8
			cv: CHECK_VIOLATION
		do
			if not condition then
				if actual /= Void then
					actual_out := actual.out
				else
					actual_out := "Void"
				end
				l_line1 := Html_start_code + "Assert Violation: " + a_name + Html_end_code
				l_line2 := Html_start_code + "Object:&nbsp&nbsp&nbsp" + actual_out + Html_end_code
				class_variable_comment_string.append (l_line1 + l_line2)
				create cv
				cv.set_description (a_name)
				cv.raise
			end
		end

	assert_equal (a_name: STRING_8; expected, actual: detachable ANY)
			-- (from ES_TEST)
		local
			l_line1, l_line2, l_line3: STRING_8
			expected_out, actual_out: STRING_8
			cv: CHECK_VIOLATION
		do
			if expected /~ actual then
				if expected /= Void then
					expected_out := expected.out
				else
					expected_out := "Void"
				end
				if actual /= Void then
					actual_out := actual.out
				else
					actual_out := "Void"
				end
				l_line1 := Html_start_code + "Assert Equal Violation: " + a_name + Html_end_code
				l_line2 := Html_start_code + "Expected: " + expected_out + Html_end_code
				l_line3 := Html_start_code + "Actual:&nbsp&nbsp&nbsp" + actual_out + Html_end_code
				class_variable_comment_string.append (l_line1 + l_line2 + l_line3)
				create cv
				cv.set_description (a_name)
				cv.raise
			end
		end

	assert_not_equal (a_name: STRING_8; expected, actual: detachable ANY)
			-- (from ES_TEST)
		local
			l_line1, l_line2, l_line3: attached STRING_8
			expected_out, actual_out: STRING_8
			cv: CHECK_VIOLATION
		do
			if expected ~ actual then
				if expected /= Void then
					expected_out := expected.out
				else
					expected_out := "Void"
				end
				if actual /= Void then
					actual_out := actual.out
				else
					actual_out := "Void"
				end
				l_line1 := Html_start_code + "Assert NOT Equal Violation: " + a_name + Html_end_code
				l_line2 := Html_start_code + "Expected: " + expected_out + Html_end_code
				l_line3 := Html_start_code + "Actual:&nbsp&nbsp&nbsp" + actual_out + Html_end_code
				class_variable_comment_string.append (l_line1 + l_line2 + l_line3)
				create cv
				cv.set_description (a_name)
				cv.raise
			end
		end

	comment (s: STRING_8)
			-- Adds s to descriptions.
			-- (from ES_TEST)
		do
			class_variable_comment_string := s
		end

	Html_end_code: STRING_8 = "</code>"
			-- (from ES_TEST)

	Html_start_code: STRING_8 = "<br><code>"
			-- (from ES_TEST)

	setup
			-- Will be executed at the beginning of "run" in a test case.
			-- (from ES_TEST)
		do
		end

	Space: STRING_8 = "&nbsp"
			-- (from ES_TEST)

	sub_comment (s: STRING_8)
			-- Adds s to comments.
			-- (from ES_TEST)
		do
			class_variable_comment_string.append ("%N" + s)
		end

	teardown
			-- Will be executed at the end of "run" in a test case.
			-- (from ES_TEST)
		do
		end
	
feature -- very long tests

	t50: BOOLEAN
		local
			x, y, r: BIG_INTEGER
		do
			comment ("t50: multiplication of two 1000 digit numbers")
			x := create {attached BIG_INTEGER}.make_from_string ("2965568378353123276348061266345783080824888634173636635747635072202278707255784767454711192972916696146985661243932638766743001420951575314525858150705284819438425780293854776985371743037095791702583725125451137558376530251552620295919831538359317595569382601550696344356463908920658071820940271591653")
			y := create {attached BIG_INTEGER}.make_from_string ("4672161668346256276894539982323613161323003926846417075720492380110430364172843882368741633254526841817867620859794648380999526377667612987783332414498121324964878519111977993241729555032137992303648692476480001375176483343253229604747667706893386237386341281432242488415592920241193919031810456388473")
			r := create {attached BIG_INTEGER}.make_from_string ("13855614902201230205396713838124973760884289654978319485082311142137827087037382261509727150448924026549639848300664275669756587958950101823084182662557603396553772413981330555796120057474978516493072772846480426310778474402862373352861984654437177663375784351271636410526463740967799532494281045773213312922392960285344870223371612383545660065429213425366297503367089113221838868648495159175215200868167451571769566788069803967064303112282810810635542749317601737077412949436378000501858987877504536107186295566967358769555137998905769629206690746812167187647482242005373441714818280697457849792215869")
			Result := x * y ~ r
		end

	t51: BOOLEAN
		local
			x, y, z, r: BIG_INTEGER
		do
			comment ("t51: division of two 1000 digit numbers")
			x := create {attached BIG_INTEGER}.make_from_string ("2965568378353123276348061266345783080824888634173636635747635072202278707255784767454711192972916696146985661243932638766743001420951575314525858150705284819438425780293854776985371743037095791702583725125451137558376530251552620295919831538359317595569382601550696344356463908920658071820940271591653")
			y := create {attached BIG_INTEGER}.make_from_string ("4672161668346256276894539982323613161323003926846417075720492380110430364172843882368741633254526841817867620859794648380999526377667612987783332414498121324964878519111977993241729555032137992303648692476480001375176483343253229604747667706893386237386341281432242488415592920241193919031810456388473")
			r := create {attached BIG_INTEGER}.make_from_string ("13855614902201230205396713838124973760884289654978319485082311142137827087037382261509727150448924026549639848300664275669756587958950101823084182662557603396553772413981330555796120057474978516493072772846480426310778474402862373352861984654437177663375784351271636410526463740967799532494281045773213312922392960285344870223371612383545660065429213425366297503367089113221838868648495159175215200868167451571769566788069803967064303112282810810635542749317601737077412949436378000501858987877504536107186295566967358769555137998905769629206690746812167187647482242005373441714818280697457849792215869")
			z := r // y
			Result := z ~ x
		end
	
feature {ES_HTML_GEN_SUITE} --test cases

	cases: detachable LINKED_LIST [ES_TEST_CASE]
			-- (from ES_TEST)

	class_variable_comment_string: STRING_8
			-- (from ES_TEST)
		attribute
			Result := ""
		end

	descriptions: detachable LINKED_LIST [STRING_8]
			-- (from ES_TEST)

	name: detachable STRING_8
			-- (from ES_TEST)
	
invariant
		-- from ANY
	reflexive_equality: standard_is_equal (Current)
	reflexive_conformance: conforms_to (Current)

end -- class INT_LONG_TEST

Generated by ISE EiffelStudio