class 
	TEST_VALUE1

create 
	make

feature {NONE} -- Initialization

	default_create
			-- Process instances of classes with no creation clause.
			-- (Default: do nothing.)
			-- (from ANY)
		do
		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 TEST_VALUE1]
			-- 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: TEST_VALUE1): 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: TEST_VALUE1): 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: TEST_VALUE1): 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: TEST_VALUE1)
			-- 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: TEST_VALUE1)
			-- 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: TEST_VALUE1
			-- 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: TEST_VALUE1)
			-- 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: TEST_VALUE1
			-- 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: TEST_VALUE1
			-- 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 TEST_VALUE1
		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 TEST_VALUE1
			-- 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 -- 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

	test0: BOOLEAN
		local
			sn1, sn2: VALUE
			answer: VALUE
		do
			comment ("test0: test multiplication: 30021.232*1.2 = 36025.4784")
			create sn1.make_from_string ("1.2")
			create sn2.make_from_string ("30021.232")
			answer := sn1 * sn2
			Result := answer.precise_out ~ "36025.4784"
			check
					Result
			end
			Result := answer.out ~ "36025.48"
		end

	test00: BOOLEAN
		local
			three, two: VALUE
			answer: VALUE
		do
			comment ("test00: checking division to 35 decimal points")
			create three.make_from_string ("3")
			answer := three.one / three
			Result := answer.precise_out ~ "0.333333333333333333333333333333333333"
			check
					Result
			end
			create two.make_from_string ("2")
			answer := two / three
			Result := answer.precise_out ~ "0.666666666666666666666666666666666666"
			check
					Result
			end
		end

	test01: BOOLEAN
		local
			v: VALUE
		do
			comment ("test01: check that 99.995.out = 100.00")
			v := create {VALUE}.make_from_string ("99.995")
			Result := v.out ~ "100.00"
			check
					Result
			end
			v := create {VALUE}.make_from_string ("999.995")
			Result := v.out ~ "1000.00"
			check
					Result
			end
		end

	test1: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test1: test addition: 123.123 + 42.5 = 165.623")
			create sn1.make_from_string ("123.123")
			create sn2.make_from_string ("42.5")
			answer := sn1 + sn2
			Result := answer.precise_out ~ "165.623"
			check
					Result
			end
			Result := answer.out ~ "165.62"
		end

	test10
		local
			sn1, sn2, answer: VALUE
		do
			comment ("violation test division: 1 / 0.0 = exception")
			create sn1.make_from_string ("1")
			create sn2.make_from_string ("0.0")
			answer := sn1 / sn2
		end

	test100: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test5: test addition: 177.00 + -000177.0 = 0")
			create sn1.make_from_string ("177.00")
			create sn2.make_from_string ("-000177.0")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "0")
			check
					Result
			end
			Result := equal (answer.out, "0.00")
		end

	test101: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test6: test addition: 99.9 + 2.1 = 102")
			create sn1.make_from_string ("99.9")
			create sn2.make_from_string ("2.1")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "102")
			check
					Result
			end
			Result := equal (answer.out, "102.00")
		end

	test102: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 99.90000000001 + 0000000000000.100000000110000000090000 = 100.00000000012000000009")
			create sn1.make_from_string ("99.90000000001")
			create sn2.make_from_string ("0000000000000.100000000110000000090000")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "100.00000000012000000009")
			check
					Result
			end
			Result := equal (answer.out, "100.00")
		end

	test103: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 100000000000.0000000000001 + 1000.001100110011023 = 100000001000.001100110011123")
			create sn1.make_from_string ("100000000000.0000000000001")
			create sn2.make_from_string ("1000.001100110011023")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "100000001000.001100110011123")
			check
					Result
			end
			Result := equal (answer.out, "100000001000.00")
		end

	test104: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: -0 + -0 = 0")
			create sn1.make_from_string ("-0")
			create sn2.make_from_string ("-0")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "0")
			check
					Result
			end
			Result := equal (answer.out, "0.00")
		end

	test105: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 198.00 + 2 = 200")
			create sn1.make_from_string ("198.00")
			create sn2.make_from_string ("2")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "200")
			check
					Result
			end
			Result := equal (answer.out, "200.00")
		end

	test106: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 202 + -02.0000 = 200")
			create sn1.make_from_string ("202")
			create sn2.make_from_string ("-02.0000")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "200")
			check
					Result
			end
			Result := equal (answer.out, "200.00")
		end

	test107: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 98 + 14 = 112")
			create sn1.make_from_string ("98")
			create sn2.make_from_string ("14")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "112")
			check
					Result
			end
			Result := equal (answer.out, "112.00")
		end

	test108: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 098.1 + 0013.9 = 112")
			create sn1.make_from_string ("098.1")
			create sn2.make_from_string ("0013.9")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "112")
			check
					Result
			end
			Result := equal (answer.out, "112.00")
		end

	test109: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: -127.00000000 + -3 = -130")
			create sn1.make_from_string ("-127.00000000")
			create sn2.make_from_string ("-3")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "-130")
			check
					Result
			end
			Result := equal (answer.out, "-130.00")
		end

	test11: BOOLEAN
		local
			zero, v0, one: VALUE
		do
			comment ("t1: check `make_from_int(0)`")
			create v0.make_from_int (0)
			create zero.make_from_string ("0")
			Result := equal (v0, zero)
			check
					Result
			end
			create one.make_from_string ("1")
			Result := equal (v0 + one, one)
		end

	test110: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 4635743657353.578395757439573577775767535734859364543534534645567578564564353426467456452675856245564675734645 + -4635743657353.578395757439573577775767535734859364543534534645567578564564353426467456452675856245564675734645 = 0")
			create sn1.make_from_string ("4635743657353.578395757439573577775767535734859364543534534645567578564564353426467456452675856245564675734645")
			create sn2.make_from_string ("-4635743657353.578395757439573577775767535734859364543534534645567578564564353426467456452675856245564675734645")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "0")
			check
					Result
			end
			Result := equal (answer.out, "0.00")
		end

	test111: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 3512765361.123812789378917389423472374238974892374982374 + 27893.234723894723897893274326578246826346 = 3512793254.358536684102815282697798952485801238374982374")
			create sn1.make_from_string ("3512765361.123812789378917389423472374238974892374982374")
			create sn2.make_from_string ("27893.234723894723897893274326578246826346")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "3512793254.358536684102815282697798952485801238374982374")
			check
					Result
			end
			Result := equal (answer.out, "3512793254.36")
		end

	test112: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 1 + -100.0 = -99")
			create sn1.make_from_string ("1")
			create sn2.make_from_string ("-100.0")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "-99")
			check
					Result
			end
			Result := equal (answer.out, "-99.00")
		end

	test113: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: -100.000 + 1 = -99")
			create sn1.make_from_string ("-100.000")
			create sn2.make_from_string ("1")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "-99")
			check
					Result
			end
			Result := equal (answer.out, "-99.00")
		end

	test114: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 999999.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 + 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 = 1000000")
			create sn1.make_from_string ("999999.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999")
			create sn2.make_from_string ("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "1000000")
			check
					Result
			end
			Result := equal (answer.out, "1000000.00")
		end

	test115: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835 + 1 = 84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657836")
			create sn1.make_from_string ("84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			create sn2.make_from_string ("1")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657836")
			check
					Result
			end
			Result := equal (answer.out, "84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657836.00")
		end

	test116: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835.456765347573489754764875825624783563478653785348975652357346378465782364534895646834906836524571435138956890456889275834651347866873815671452365434786893256278361423571348956347825678583513478512365783457372523456356426457825891345678462378423784615786132552361347851734891237429 + 1 = 84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657836.456765347573489754764875825624783563478653785348975652357346378465782364534895646834906836524571435138956890456889275834651347866873815671452365434786893256278361423571348956347825678583513478512365783457372523456356426457825891345678462378423784615786132552361347851734891237429")
			create sn1.make_from_string ("84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835.456765347573489754764875825624783563478653785348975652357346378465782364534895646834906836524571435138956890456889275834651347866873815671452365434786893256278361423571348956347825678583513478512365783457372523456356426457825891345678462378423784615786132552361347851734891237429")
			create sn2.make_from_string ("1")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657836.456765347573489754764875825624783563478653785348975652357346378465782364534895646834906836524571435138956890456889275834651347866873815671452365434786893256278361423571348956347825678583513478512365783457372523456356426457825891345678462378423784615786132552361347851734891237429")
			check
					Result
			end
			Result := equal (answer.out, "84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657836.46")
		end

	test117: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test addition: 0.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835 + 1 = 1.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			create sn1.make_from_string ("0.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			create sn2.make_from_string ("1")
			answer := sn1 + sn2
			Result := equal (answer.precise_out, "1.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			check
					Result
			end
			Result := equal (answer.out, "1.84")
		end

	test12: BOOLEAN
		local
			v1, v2, v3: VALUE
		do
			comment ("t1: check `make_from_int(n)` for n < 0")
			create v1.make_from_int (-3)
			check
					v1 < v1.zero
			end
			create v2.make_from_string ("-3")
			check
					equal (v1, v2)
			end
			create v3.make_from_int (3)
			Result := equal (v1 + v3, v1.zero)
		end

	test13: BOOLEAN
		local
			v1, v2, v3, v4: VALUE
		do
			comment ("t13: test conversion to DOUBLE")
			create v1.make_from_string ("23.4")
			create v2.make_from_string ("-10.0")
			v3 := v1 + v2
			create v4.make_from_string ("13.4")
			Result := v1 + v2 ~ v4
			check
					Result
			end
			Result := v1.as_double > 23.2 and v1 > v2 and v2.as_double < -9.4
			check
					Result
			end
			v1 := create {VALUE}.make_from_string ("23.4")
			Result := v1 ~ create {VALUE}.make_from_string ("23.4")
		end

	test2: BOOLEAN
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test2: test that 42.5 < 123.123")
			create sn1.make_from_string ("123.123")
			create sn2.make_from_string ("42.5")
			Result := sn2 < sn1
		end

	test200: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 177.00 - -000177.0 = 354")
			create sn1.make_from_string ("177.00")
			create sn2.make_from_string ("-000177.0")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "354")
			check
					Result
			end
			Result := equal (answer.out, "354.00")
		end

	test201: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 177.00 - -000177.0 = 354")
			create sn1.make_from_string ("177.00")
			create sn2.make_from_string ("-000177.0")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "354")
			check
					Result
			end
			Result := equal (answer.out, "354.00")
		end

	test202: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 177.00 - 0177.00000000 = 0")
			create sn1.make_from_string ("177.00")
			create sn2.make_from_string ("0177.00000000")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "0")
			check
					Result
			end
			Result := equal (answer.out, "0.00")
		end

	test203: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 99.9 - 2.1 = 97.8")
			create sn1.make_from_string ("99.9")
			create sn2.make_from_string ("2.1")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "97.8")
			check
					Result
			end
			Result := equal (answer.out, "97.80")
		end

	test204: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 112 - 98.7 = 13.3")
			create sn1.make_from_string ("112")
			create sn2.make_from_string ("98.7")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "13.3")
			check
					Result
			end
			Result := equal (answer.out, "13.30")
		end

	test205: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 112 - 98 = 14")
			create sn1.make_from_string ("112")
			create sn2.make_from_string ("98")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "14")
			check
					Result
			end
			Result := equal (answer.out, "14.00")
		end

	test206: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 99.90000000001 - 0000000000000.100000000110000000090000 = 99.79999999989999999991")
			create sn1.make_from_string ("99.90000000001")
			create sn2.make_from_string ("0000000000000.100000000110000000090000")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "99.79999999989999999991")
			check
					Result
			end
			Result := equal (answer.out, "99.80")
		end

	test207: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 100000000000.0000000000001 - 1000.001100110011023 = 99999998999.998899889989077")
			create sn1.make_from_string ("100000000000.0000000000001")
			create sn2.make_from_string ("1000.001100110011023")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "99999998999.998899889989077")
			check
					Result
			end
			Result := equal (answer.out, "99999999000.00")
		end

	test208: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 100000000000.0000000000001 - 1000.001100110011023 = 99999998999.998899889989077")
			create sn1.make_from_string ("100000000000.0000000000001")
			create sn2.make_from_string ("1000.001100110011023")
			answer := sn1 + - sn2
			Result := equal (answer.precise_out, "99999998999.998899889989077")
			check
					Result
			end
			Result := equal (answer.out, "99999999000.00")
		end

	test209: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 1 - 100.0 = -99")
			create sn1.make_from_string ("1")
			create sn2.make_from_string ("100.0")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "-99")
			check
					Result
			end
			Result := equal (answer.out, "-99.00")
		end

	test210: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 100.1 - 1 = 99.1")
			create sn1.make_from_string ("100.1")
			create sn2.make_from_string ("1")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "99.1")
			check
					Result
			end
			Result := equal (answer.out, "99.10")
		end

	test211: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 100 - 1.00 = 99")
			create sn1.make_from_string ("100")
			create sn2.make_from_string ("1.00")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "99")
			check
					Result
			end
			Result := equal (answer.out, "99.00")
		end

	test212: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 12 - 125.456 = -113.456")
			create sn1.make_from_string ("12")
			create sn2.make_from_string ("125.456")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "-113.456")
			check
					Result
			end
			Result := equal (answer.out, "-113.46")
		end

	test213: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: -12 - 125.456 = -137.456")
			create sn1.make_from_string ("-12")
			create sn2.make_from_string ("125.456")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "-137.456")
			check
					Result
			end
			Result := equal (answer.out, "-137.46")
		end

	test214: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: -12 - -125.456 = 113.456")
			create sn1.make_from_string ("-12")
			create sn2.make_from_string ("-125.456")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "113.456")
			check
					Result
			end
			Result := equal (answer.out, "113.46")
		end

	test215: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 125.456 - 12 = 113.456")
			create sn1.make_from_string ("125.456")
			create sn2.make_from_string ("12")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "113.456")
			check
					Result
			end
			Result := equal (answer.out, "113.46")
		end

	test216: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 098.1 - 0013.9 = 84.2")
			create sn1.make_from_string ("098.1")
			create sn2.make_from_string ("0013.9")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "84.2")
			check
					Result
			end
			Result := equal (answer.out, "84.20")
		end

	test217: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: -127.00000000 - -3 = -124")
			create sn1.make_from_string ("-127.00000000")
			create sn2.make_from_string ("-3")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "-124")
			check
					Result
			end
			Result := equal (answer.out, "-124.00")
		end

	test218: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 4635743657353.578395757439573577775767535734859364543534534645567578564564353426467456452675856245564675734645 - 4635743657353.578395757439573577775767535734859364543534534645567578564564353426467456452675856245564675734645 = 0")
			create sn1.make_from_string ("4635743657353.578395757439573577775767535734859364543534534645567578564564353426467456452675856245564675734645")
			create sn2.make_from_string ("4635743657353.578395757439573577775767535734859364543534534645567578564564353426467456452675856245564675734645")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "0")
			check
					Result
			end
			Result := equal (answer.out, "0.00")
		end

	test219: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 3512765361.123812789378917389423472374238974892374982374 - 27893.234723894723897893274326578246826346 = 3512737467.889088894655019496149145795992148546374982374")
			create sn1.make_from_string ("3512765361.123812789378917389423472374238974892374982374")
			create sn2.make_from_string ("27893.234723894723897893274326578246826346")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "3512737467.889088894655019496149145795992148546374982374")
			check
					Result
			end
			Result := equal (answer.out, "3512737467.89")
		end

	test22: BOOLEAN
		local
			num1: VALUE
			answer: STRING_8
			answer2: VALUE
		do
			comment ("test22")
			create num1.make_from_string ("3.4344334455635543332")
			answer := num1.precise_out_to (10)
			Result := answer ~ "3.4344334455"
			check
					Result
			end
			create num1.make_from_string ("3.4344334455335543332")
			answer2 := num1.round_to (8)
			Result := answer2.precise_out ~ "3.43443345"
			check
					Result
			end
		end

	test220: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 999999.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 - 0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 = 999999")
			create sn1.make_from_string ("999999.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999")
			create sn2.make_from_string ("0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "999999")
			check
					Result
			end
			Result := equal (answer.out, "999999.00")
		end

	test221: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 999999.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999 - 999999 = 0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999")
			create sn1.make_from_string ("999999.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999")
			create sn2.make_from_string ("999999")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "0.9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999")
			check
					Result
			end
			Result := equal (answer.out, "1.00")
		end

	test222: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835 - 1 = 84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657834")
			create sn1.make_from_string ("84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			create sn2.make_from_string ("1")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657834")
			check
					Result
			end
			Result := equal (answer.out, "84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657834.00")
		end

	test223: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835.5734895734895789347895634789573490583904587624875893534890589038649068908790356890585649578935734897689764897869057890576987935768573465893276857468978968234753897583495734895734895738945738945738943895738957357 - 1 = 84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657834.5734895734895789347895634789573490583904587624875893534890589038649068908790356890585649578935734897689764897869057890576987935768573465893276857468978968234753897583495734895734895738945738945738943895738957357")
			create sn1.make_from_string ("84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835.5734895734895789347895634789573490583904587624875893534890589038649068908790356890585649578935734897689764897869057890576987935768573465893276857468978968234753897583495734895734895738945738945738943895738957357")
			create sn2.make_from_string ("1")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657834.5734895734895789347895634789573490583904587624875893534890589038649068908790356890585649578935734897689764897869057890576987935768573465893276857468978968234753897583495734895734895738945738945738943895738957357")
			check
					Result
			end
			Result := equal (answer.out, "84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657834.57")
		end

	test224: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 1 - 84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835 = -84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657834")
			create sn1.make_from_string ("1")
			create sn2.make_from_string ("84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "-84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657834")
			check
					Result
			end
			Result := equal (answer.out, "-84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657834.00")
		end

	test225: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 1.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835 - 1 = 0.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			create sn1.make_from_string ("1.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			create sn2.make_from_string ("1")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "0.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			check
					Result
			end
			Result := equal (answer.out, "0.84")
		end

	test226: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 1 - 1.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835 = -0.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			create sn1.make_from_string ("1")
			create sn2.make_from_string ("1.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "-0.84395743648584735894737856356473598473589674573452345789736734583847586374357823583585623562437538957677456437589375894736583654736578365783465782346578436578346578634576356436578436543567843657843657834658734656347564356473564735643567436578435636547365784365843657835")
			check
					Result
			end
			Result := equal (answer.out, "-0.84")
		end

	test227: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 1 - .1 = 0.9")
			create sn1.make_from_string ("1")
			create sn2.make_from_string (".1")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "0.9")
			check
					Result
			end
			Result := equal (answer.out, "0.90")
		end

	test3: BOOLEAN
		local
			v1, v2, v3: VALUE
		do
			comment ("test3: test money value equality")
			create v1.make_from_string ("123.12345678999876")
			create v2.make_from_string ("123.12345678999875")
			create v3.make_from_string ("123.12345678999876")
			Result := v1 ~ v3 and v1 /~ v2
		end

	test300: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test8: test operator <: 1.2 < 2.3 = true")
			create sn1.make_from_string ("1.2")
			create sn2.make_from_string ("2.3")
			Result := sn1 < sn2
		end

	test301: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test8: test operator <: -5.00000 < -4.0000 = true")
			create sn1.make_from_string ("-5.00000")
			create sn2.make_from_string ("-4.0000")
			Result := sn1 < sn2
		end

	test302: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: -0005.00000 < 0 = true")
			create sn1.make_from_string ("-0005.00000")
			create sn2.make_from_string ("0")
			Result := sn1 < sn2
		end

	test303: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: -0.055555 < 5 = true")
			create sn1.make_from_string ("-0.055555")
			create sn2.make_from_string ("5")
			Result := sn1 < sn2
		end

	test304: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: -0 < 0 = false")
			create sn1.make_from_string ("-0")
			create sn2.make_from_string ("0")
			Result := not (sn1 < sn2)
		end

	test305: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: 0 < 0 = false")
			create sn1.make_from_string ("0")
			create sn2.make_from_string ("0")
			Result := not (sn1 < sn2)
		end

	test306: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: 0.99999999999999999999999999999999999999999999999999999999999999999 < 1 = true")
			create sn1.make_from_string ("0.99999999999999999999999999999999999999999999999999999999999999999")
			create sn2.make_from_string ("1")
			Result := sn1 < sn2
		end

	test307: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: 1 < 0.99999999999999999999999999999999999999999999999999999999999999999 = false")
			create sn1.make_from_string ("1")
			create sn2.make_from_string ("0.99999999999999999999999999999999999999999999999999999999999999999")
			Result := not (sn1 < sn2)
		end

	test308: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: 0.999998 < 0.999999 = true")
			create sn1.make_from_string ("0.999998")
			create sn2.make_from_string ("0.999999")
			Result := sn1 < sn2
		end

	test309: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: 1.00000000000 < 00000000000.2 = false")
			create sn1.make_from_string ("1.00000000000")
			create sn2.make_from_string ("00000000000.2")
			Result := not (sn1 < sn2)
		end

	test310: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: 42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729347 < 42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729348 = true")
			create sn1.make_from_string ("42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729347")
			create sn2.make_from_string ("42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729348")
			Result := sn1 < sn2
		end

	test4: BOOLEAN
			-- test addition
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test4: test addition: 1285 + 1387 = 2672")
			create sn1.make_from_string ("1285")
			create sn2.make_from_string ("1387")
			answer := sn1 + sn2
			Result := answer.precise_out ~ "2672"
			check
					Result
			end
			Result := answer.out ~ "2672.00"
		end

	test400: BOOLEAN
			-- test operator == (yes, ==, not =; this is NOT a typo)
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator ==: 10.000 == 010.00000000000 = true")
			create sn1.make_from_string ("10.000")
			create sn2.make_from_string ("010.00000000000")
			Result := sn1.is_equal (sn2)
		end

	test401: BOOLEAN
			-- test operator == (yes, ==, not =; this is NOT a typo)
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator ==: 10.000 == -10.0 = false")
			create sn1.make_from_string ("10.000")
			create sn2.make_from_string ("-10.0")
			Result := not sn1.is_equal (sn2)
		end

	test402: BOOLEAN
			-- test operator == (yes, ==, not =; this is NOT a typo)
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator ==: 347862462746.4237489238472893478924 == 000000347862462746.423748923847289347892400000000000000000 = true")
			create sn1.make_from_string ("347862462746.4237489238472893478924")
			create sn2.make_from_string ("000000347862462746.423748923847289347892400000000000000000")
			Result := sn1.is_equal (sn2)
		end

	test403: BOOLEAN
			-- test operator == (yes, ==, not =; this is NOT a typo)
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator ==: -0 == 0 = true")
			create sn1.make_from_string ("-0")
			create sn2.make_from_string ("0")
			Result := sn1.is_equal (sn2)
		end

	test404: BOOLEAN
			-- test operator == (yes, ==, not =; this is NOT a typo)
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: 42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729347 < 42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729348 = true")
			create sn1.make_from_string ("42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729347")
			create sn2.make_from_string ("42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729348")
			Result := not sn1.is_equal (sn2)
		end

	test405: BOOLEAN
			-- test operator == (yes, ==, not =; this is NOT a typo)
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator <: 42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729347 < 42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729347 = true")
			create sn1.make_from_string ("42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729347")
			create sn2.make_from_string ("42365473386374785637856437889849023849027453758346578365348929048012845738945364742378563489573495682359753657451565678345748643675895347861587618958736578134895637857348957348534895789345.5348738578498239758753753487457896346573465734897817587658349723897418567134865783464782357465234728947892561462389472356473561742389482653465123489234537561478239848915613476237842837418951347867234238561347623894792561488956346589478914791728957145612894792578947891247238947239472347238471479237849729347")
			Result := sn1.is_equal (sn2)
		end

	test5: BOOLEAN
			-- test subtraction
		local
			sn1: VALUE
			sn2: VALUE
			answer: VALUE
		do
			comment ("test subtraction: 1285 - 1387 = -102")
			create sn1.make_from_string ("1285")
			create sn2.make_from_string ("1387")
			answer := sn1 - sn2
			Result := equal (answer.precise_out, "-102")
			check
					Result
			end
			Result := equal (answer.out, "-102.00")
		end

	test8: BOOLEAN
			-- test operator <
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test8: test operator <: 1.2 < 2.3 = true")
			create sn1.make_from_string ("1.2")
			create sn2.make_from_string ("2.3")
			Result := sn1 < sn2
			check
					Result = True
			end
		end

	test9: BOOLEAN
			-- test operator == (yes, ==, not =; this is NOT a typo)
		local
			sn1: VALUE
			sn2: VALUE
		do
			comment ("test operator ==: 10.000000 == 10 = true")
			create sn1.make_from_string ("10.000000")
			create sn2.make_from_string ("10")
			Result := sn1.is_equal (sn2)
		end
	
feature {NONE} -- in it

	make
			-- create the test
		do
			add_boolean_case (agent test01)
			add_boolean_case (agent test11)
			add_boolean_case (agent test22)
			add_boolean_case (agent test0)
			add_boolean_case (agent test1)
			add_boolean_case (agent test2)
			add_boolean_case (agent test3)
			add_boolean_case (agent test4)
			add_boolean_case (agent test5)
			add_boolean_case (agent test8)
			add_boolean_case (agent test9)
			add_boolean_case (agent test12)
			add_boolean_case (agent test13)
			add_boolean_case (agent test100)
			add_boolean_case (agent test101)
			add_boolean_case (agent test102)
			add_boolean_case (agent test103)
			add_boolean_case (agent test104)
			add_boolean_case (agent test105)
			add_boolean_case (agent test106)
			add_boolean_case (agent test107)
			add_boolean_case (agent test108)
			add_boolean_case (agent test109)
			add_boolean_case (agent test110)
			add_boolean_case (agent test111)
			add_boolean_case (agent test112)
			add_boolean_case (agent test113)
			add_boolean_case (agent test114)
			add_boolean_case (agent test115)
			add_boolean_case (agent test116)
			add_boolean_case (agent test117)
			add_boolean_case (agent test200)
			add_boolean_case (agent test201)
			add_boolean_case (agent test202)
			add_boolean_case (agent test203)
			add_boolean_case (agent test204)
			add_boolean_case (agent test205)
			add_boolean_case (agent test206)
			add_boolean_case (agent test207)
			add_boolean_case (agent test208)
			add_boolean_case (agent test209)
			add_boolean_case (agent test210)
			add_boolean_case (agent test211)
			add_boolean_case (agent test212)
			add_boolean_case (agent test213)
			add_boolean_case (agent test214)
			add_boolean_case (agent test215)
			add_boolean_case (agent test216)
			add_boolean_case (agent test217)
			add_boolean_case (agent test218)
			add_boolean_case (agent test219)
			add_boolean_case (agent test220)
			add_boolean_case (agent test221)
			add_boolean_case (agent test222)
			add_boolean_case (agent test223)
			add_boolean_case (agent test224)
			add_boolean_case (agent test225)
			add_boolean_case (agent test226)
			add_boolean_case (agent test227)
			add_boolean_case (agent test300)
			add_boolean_case (agent test301)
			add_boolean_case (agent test302)
			add_boolean_case (agent test303)
			add_boolean_case (agent test304)
			add_boolean_case (agent test305)
			add_boolean_case (agent test306)
			add_boolean_case (agent test307)
			add_boolean_case (agent test308)
			add_boolean_case (agent test309)
			add_boolean_case (agent test310)
			add_boolean_case (agent test400)
			add_boolean_case (agent test401)
			add_boolean_case (agent test402)
			add_boolean_case (agent test403)
			add_boolean_case (agent test404)
			add_boolean_case (agent test405)
		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 {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 TEST_VALUE1

Generated by ISE EiffelStudio