indexing
	description: "test all filters. "
	library: "elogger"
	copyright: "Copyright (c) 2006, AXA Rosenberg, and others (see copyright.txt)"
	author: "Ulrich Weiss, and others"
	license: "Eiffel Forum License v2 (see forum.txt)"
	date: "$Date: $"
	revision: "$Revision: $"
	archive: "$Archive: $"

deferred class TEST_ELOG_FILTERS

inherit

    TS_TEST_CASE
    	undefine
    		name_of_id,
    		execute_i_th
    	end

    ELOG_SEVERITY_CONSTANTS
		export
			{NONE} all
		end

	ELOG_FILTER_CONSTANTS
		export
			{NONE} all
		end

feature -- Test

	test_priority_match_filter is
			-- test priority match filter
		local
			filter: ELOG_FILTER
			event: ELOG_SIMPLE_EVENT
		do
			create {ELOG_SEVERITY_MATCH_FILTER} filter.make (Information_severity, True)
			create event.make ("test event")
			event.set_severity (Information_severity)
			assert_equal ("info_match", filter.decide (event), Filter_accept)
			create event.make ("test event")
			event.set_severity (Unknown_severity)
			assert_equal ("info_not_match_debug", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Harmless_severity)
			assert_equal ("info_not_match_warn", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Critical_severity)
			assert_equal ("info_not_match_error", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Fatal_severity)
			assert_equal ("info_not_match_fatal", filter.decide (event), Filter_neutral)

			create {ELOG_SEVERITY_MATCH_FILTER} filter.make (Information_severity, False)
			create event.make ("test event")
			event.set_severity (Information_severity)
			assert_equal ("info_match", filter.decide (event), Filter_reject)
			create event.make ("test event")
			event.set_severity (Unknown_severity)
			assert_equal ("info_not_match_debug", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Harmless_severity)
			assert_equal ("info_not_match_warn", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Critical_severity)
			assert_equal ("info_not_match_error", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Fatal_severity)
			assert_equal ("info_not_match_fatal", filter.decide (event), Filter_neutral)
		end

	test_severity_range_filter is
			-- test severity match filter
		local
			filter: ELOG_FILTER
			event: ELOG_SIMPLE_EVENT
		do
			-- Range includes Info, Warn and Error. Accept on range match.
			create {ELOG_SEVERITY_RANGE_FILTER} filter.make (Information_severity, Critical_severity, True)
			create event.make ("test event")
			event.set_severity (Information_severity)
			assert_equal ("info_match", filter.decide (event), Filter_accept)
			create event.make ("test event")
			event.set_severity (Warning_severity)
			assert_equal ("warn_match", filter.decide (event), Filter_accept)
			create event.make ("test event")
			event.set_severity (Critical_severity)
			assert_equal ("critical_match", filter.decide (event), Filter_accept)
			create event.make ("test event")
			event.set_severity (Fatal_severity)
			assert_equal ("fatal_not_match", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Unknown_severity)
			assert_equal ("unknown_not_match", filter.decide (event), Filter_neutral)

			-- Range includes Info, Warn and Error. Reject on range match.
			create {ELOG_SEVERITY_RANGE_FILTER} filter.make (Information_severity, Critical_severity, False)
			create event.make ("test event")
			event.set_severity (Information_severity)
			assert_equal ("info_match", filter.decide (event), Filter_reject)
			create event.make ("test event")
			event.set_severity (Warning_severity)
			assert_equal ("warn_match", filter.decide (event), Filter_reject)
			create event.make ("test event")
			event.set_severity (Critical_severity)
			assert_equal ("critical_match", filter.decide (event), Filter_reject)
			create event.make ("test event")
			event.set_severity (Fatal_severity)
			assert_equal ("fatal_not_match", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Unknown_severity)
			assert_equal ("unknown_not_match", filter.decide (event), Filter_neutral)

			-- Range includes minor, crit, fatal. Accept on range match.
			create {ELOG_SEVERITY_RANGE_FILTER} filter.make (Minor_severity, Void, True)
			create event.make ("test event")
			event.set_severity (Information_severity)
			assert_equal ("info_match", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Warning_severity)
			assert_equal ("warn_match", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Critical_severity)
			assert_equal ("critical_match", filter.decide (event), Filter_accept)
			create event.make ("test event")
			event.set_severity (Fatal_severity)
			assert_equal ("fatal_not_match", filter.decide (event), Filter_accept)
			create event.make ("test event")
			event.set_severity (Unknown_severity)
			assert_equal ("unknown_not_match", filter.decide (event), Filter_neutral)

			-- Range includes minor, warning, harmless, info, unknown. Accept on range match.
			create {ELOG_SEVERITY_RANGE_FILTER} filter.make (Void, Minor_severity, False)
			create event.make ("test event")
			event.set_severity (Information_severity)
			assert_equal ("info_match", filter.decide (event), Filter_reject)
			create event.make ("test event")
			event.set_severity (Warning_severity)
			assert_equal ("warn_match", filter.decide (event), Filter_reject)
			create event.make ("test event")
			event.set_severity (Critical_severity)
			assert_equal ("critical_match", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Fatal_severity)
			assert_equal ("fatal_not_match", filter.decide (event), Filter_neutral)
			create event.make ("test event")
			event.set_severity (Unknown_severity)
			assert_equal ("unknown_not_match", filter.decide (event), Filter_reject)
		end

	test_string_match_filter is
			-- test string match filter
		local
			filter: ELOG_FILTER
			event: ELOG_SIMPLE_EVENT
		do
			create {ELOG_STRING_MATCH_FILTER} filter.make ("match", True)
			create event.make ("this contains match")
			assert_equal ("match_true", filter.decide (event), Filter_accept)
			create event.make ("doesn't contain it")
			assert_equal ("no_match_true", filter.decide (event), Filter_neutral)

			create {ELOG_STRING_MATCH_FILTER} filter.make ("match", False)
			create event.make ("this contains match")
			assert_equal ("match_false", filter.decide (event), Filter_reject)
			create event.make ("doesn't contain it")
			assert_equal ("no_match_false", filter.decide (event), Filter_neutral)
		end

	test_filter_tree is
			-- tests ELOG_AND_FILTER
		local
			f1: ELOG_ACCEPT_FILTER
			f2: ELOG_REJECT_FILTER
			f3: ELOG_NEUTRAL_FILTER
			f_and: ELOG_AND_FILTER
			f_or: ELOG_OR_FILTER
			e: ELOG_SIMPLE_EVENT
			f_conv_a: ELOG_NEUTRAL_TO_ACCEPT_FILTER
			f_conv_r: ELOG_NEUTRAL_TO_REJECT_FILTER
		do
			create e.make ("t")
			create f1.make
			create f2.make
			create f3.make

			-- test and of accepts
			create f_and.make (f1, f1, False)
			assert_equal ("and_accept", f_and.decide (e), Filter_accept)
			f_and.add_filter (f1)
			assert_equal ("and_accept", f_and.decide (e), Filter_accept)
			f_and.add_filter (f3)
			assert_equal ("and_accept", f_and.decide (e), Filter_accept)
			f_and.add_filter (f2)
			assert_equal ("and_accept", f_and.decide (e), Filter_reject)

			-- test and of rejects
			create f_and.make (f2, f2, True)
			assert_equal ("and_accept", f_and.decide (e), Filter_reject)
			f_and.add_filter (f2)
			assert_equal ("and_accept", f_and.decide (e), Filter_reject)
			f_and.add_filter (f3)
			assert_equal ("and_accept", f_and.decide (e), Filter_reject)
			f_and.add_filter (f1)
			assert_equal ("and_accept", f_and.decide (e), Filter_accept)

			-- test or of accepts
			create f_or.make (f2, f2, False)
			assert_equal ("and_accept", f_or.decide (e), Filter_reject)
			f_or.add_filter (f3)
			assert_equal ("and_accept", f_or.decide (e), Filter_reject)
			f_or.add_filter (f1)
			assert_equal ("and_accept", f_or.decide (e), Filter_accept)
			f_or.add_filter (f2)
			assert_equal ("and_accept", f_or.decide (e), Filter_accept)

			-- test or of rejects
			create f_or.make (f1, f1, True)
			assert_equal ("and_accept", f_or.decide (e), Filter_accept)
			f_or.add_filter (f3)
			assert_equal ("and_accept", f_or.decide (e), Filter_accept)
			f_or.add_filter (f2)
			assert_equal ("and_accept", f_or.decide (e), Filter_reject)
			f_or.add_filter (f1)
			assert_equal ("and_accept", f_or.decide (e), Filter_reject)

			-- test and neutrals
			create f_and.make (f3, f3, False)
			assert_equal ("and_neutral", f_and.decide (e), Filter_neutral)
			f_and.add_filter (f1)
			assert_equal ("and_accept", f_and.decide (e), Filter_accept)
			f_and.add_filter (f2)
			assert_equal ("and_accept", f_and.decide (e), Filter_reject)

			-- test and neutrals
			create f_and.make (f3, f3, True)
			assert_equal ("and_neutral", f_and.decide (e), Filter_neutral)
			f_and.add_filter (f2)
			assert_equal ("and_accept", f_and.decide (e), Filter_reject)
			f_and.add_filter (f1)
			assert_equal ("and_accept", f_and.decide (e), Filter_accept)

			-- test or neutrals
			create f_or.make (f3, f3, False)
			assert_equal ("and_accept", f_or.decide (e), Filter_neutral)
			f_or.add_filter (f2)
			assert_equal ("and_accept", f_or.decide (e), Filter_reject)
			f_or.add_filter (f1)
			assert_equal ("and_accept", f_or.decide (e), Filter_accept)

			-- test or neutrals
			create f_or.make (f3, f3, True)
			assert_equal ("and_accept", f_or.decide (e), Filter_neutral)
			f_or.add_filter (f1)
			assert_equal ("and_accept", f_or.decide (e), Filter_accept)
			f_or.add_filter (f2)
			assert_equal ("and_accept", f_or.decide (e), Filter_reject)

			-- test convert neutrals
			create f_conv_a.make (f3)
			assert_equal ("and_accept", f_conv_a.decide (e), Filter_accept)
			create f_conv_r.make (f3)
			assert_equal ("and_accept", f_conv_r.decide (e), Filter_reject)
		end

end