extends GutInternalTester


class TestArrayCompareResultInterace:
	extends GutInternalTester

	var DiffTool = GutUtils.DiffTool

	func test_cannot_set_summary():
		var ad = DiffTool.new([], [])
		ad.summary = 'the summary'
		assert_push_error('cannot set summary')
		assert_ne(ad.summary,  'the summary')

	func test_summary_prop_returns_summarize():
		var ad =  DiffTool.new([], [1])
		assert_not_null(ad.summary)

	func test_cannot_set_are_equal():
		var ad = DiffTool.new([], [])
		ad.are_equal = 'asdf'
		assert_push_error('cannot set are_equal')
		assert_eq(ad.are_equal, true)

	func test_are_equal_prop_returns_result_of_diff():
		var ad = DiffTool.new([], [])
		assert_eq(ad.are_equal, true)

	func test_get_total_different_returns_correct_count():
		var diff = DiffTool.new([1, 2, 3], [1, 'two', 99, 'four'])
		assert_eq(diff.get_different_count(), 3)

	var _total_count_vars = [
		[[1, 2, 3], [1, 2, 3, 4], 4],
		[[1, 2, 3, 4], [1, 2, 3], 4],
		[[1, 2], [1, 2], 2]
	]
	func test_get_total_count_returns_correct_count(p=use_parameters(_total_count_vars)):
		var diff = DiffTool.new(p[0], p[1])
		assert_eq(diff.get_total_count(), p[2])

	func test_get_short_summary_includes_x_of_y_keys_when_different():
		var diff = DiffTool.new([1, 2, 3, 4], [1, 'a', 'b', 'c', 'd'], GutUtils.DIFF.DEEP)
		assert_string_contains(diff.get_short_summary(), '4 of 5')

	func test_get_short_summary_does_not_include_x_of_y_when_equal():
		var diff = DiffTool.new([], [], GutUtils.DIFF.DEEP)
		assert_eq(diff.get_short_summary().find(' of '), -1, diff.get_short_summary())
		assert_string_contains(diff.get_short_summary(), '==')

	func test_brackets():
		var diff = DiffTool.new([], [])
		assert_eq(diff.get_brackets().open, '[', 'open')
		assert_eq(diff.get_brackets().close, ']', 'close')


class TestArrayDiff:
	extends GutInternalTester

	var DiffTool = GutUtils.DiffTool

	func test_can_instantiate_with_two_arrays():
		var ad  = DiffTool.new([], [])
		assert_not_null(ad)

	func test_constructor_defaults_diff_type_to_deep():
		var diff = DiffTool.new([], [])
		assert_eq(diff.get_diff_type(), GutUtils.DIFF.DEEP)

	func test_constructor_sets_diff_type():
		var diff = DiffTool.new([], [], GutUtils.DIFF.SIMPLE)
		assert_eq(diff.get_diff_type(), GutUtils.DIFF.SIMPLE)

	func test_is_equal_is_true_when_all_elements_match():
		var ad = DiffTool.new([1, 2, 3], [1, 2, 3])
		assert_true(ad.are_equal)

	func test_is_equal_returns_false_when_one_element_does_not_match():
		var ad = DiffTool.new([1, 2, 3], [1, 2, 99])
		assert_false(ad.are_equal, 'should be false but is ' + str(ad.are_equal))

	func test_lists_indexes_as_missing_in_first_array():
		var ad = DiffTool.new([1, 2, 3], [1, 2, 3, 4, 5])
		assert_string_contains(ad.summarize(), '<missing index> !=')

	func test_get_summary_text_lists_both_arrays():
		var ad = DiffTool.new([3, 2, 1, 98, 99], [1, 2, 3])
		assert_string_contains(ad.summarize(), '[3, 2, 1, 98, 99] != [1, 2, 3]')

	func test_get_summary_text_lists_differences():
		var ad = DiffTool.new([3, 2, 1, 98, 99], [1, 2, 3])
		assert_string_contains(ad.summarize(), '0:  3 !=')

	func test_when_arrays_are_large_then_summarize_truncates():
		var a1 = []
		var a2 = []
		for i in range(100):
			a1.append(i)
			if(i%2 == 0):
				a2.append(str(i))
			else:
				if(i < 90):
					a2.append(i)

		var ad = DiffTool.new(a1, a2)
		var summary = ad.summarize()
		assert_lt(summary.split("\n").size(), 40, summary)

	func test_works_with_strings_and_numbers():
		var a1 = [0, 1, 2, 3, 4]
		var a2 = [0, 'one', 'two', 'three', '4']
		var ad = DiffTool.new(a1, a2)
		gut.p(ad.summarize())
		pass_test('we got here')

	func test_when_arrays_are_equal_summarize_says_so():
		var ad = DiffTool.new(['a', 'b', 'c'], ['a', 'b', 'c'])
		assert_string_contains(ad.summarize(), ' == ')

	func test_diff_display_with_classes():
		var d_test = double(GutTest).new()
		var a1 = [gut, d_test]
		var a2 = [d_test, gut]
		var ad  = DiffTool.new(a1, a2)
		assert_string_contains(ad.summarize(), '(gut.gd)')
		assert_string_contains(ad.summarize(), 'double of test.gd')

	func test_diff_display_with_classes2():
		var d_test_1 = double(GutTest).new()
		var d_test_2 = double(GutTest).new()
		var a1 = [d_test_1, d_test_2]
		var a2 = [d_test_2, d_test_1]
		var ad  = DiffTool.new(a1, a2)
		assert_string_contains(ad.summarize(), 'double of test.gd')

	func test_dictionaries_in_sub_arrays():
		var a1 = [[{'a': 1}]]
		var a2 = [[{'a': 1}]]
		var diff = DiffTool.new(a1, a2, GutUtils.DIFF.SIMPLE)
		assert_true(diff.are_equal, diff.summarize())


class TestArrayDeepDiff:
	extends GutInternalTester

	var DiffTool = GutUtils.DiffTool

	func test_diff_with_dictionaries_passes_when_not_same_reference_but_same_values():
		var a1 = [{'a':1}, {'b':2}]
		var a2 = [{'a':1}, {'b':2}]
		var diff = DiffTool.new(a1, a2, GutUtils.DIFF.DEEP)
		assert_true(diff.are_equal, diff.summarize())

	func test_diff_with_dictionaries_fails_when_different_values():
		var a1 = [{'a':1}, {'b':1}, {'c':1}, {'d':1}]
		var a2 = [{'a':1}, {'b':2}, {'c':2}, {'d':2}]
		var diff = DiffTool.new(a1, a2, GutUtils.DIFF.DEEP)
		assert_false(diff.are_equal, diff.summarize())

	func test_matching_dictionaries_in_sub_arrays():
		var a1 = [[{'a': 1}]]
		var a2 = [[{'a': 1}]]
		var diff = DiffTool.new(a1, a2, GutUtils.DIFF.DEEP)
		assert_true(diff.are_equal, diff.summarize())

	func test_non_matching_dictionaries_in_sub_arrays():
		var a1 = [[{'a': 1}], [{'b': 1}], [{'c': 1}]]
		var a2 = [[{'a': 1}], [{'b': 2}], [{'c': 2}]]
		var diff = DiffTool.new(a1, a2, GutUtils.DIFF.DEEP)
		assert_false(diff.are_equal, diff.summarize())

	func test_when_deep_compare_non_equal_dictionaries_do_not_contain_disclaimer():
		var a1 = [[{'a': 2}], [{'b': 3}], [{'c': 4}]]
		var a2 = [[{'a': 1}], [{'b': 2}], [{'c': 2}]]
		var diff = DiffTool.new(a1, a2, GutUtils.DIFF.DEEP)
		assert_eq(diff.summary.find('reference'), -1, diff.summary)


class TestDictionaryCompareResultInterace:
	extends GutInternalTester

	var DiffTool = GutUtils.DiffTool

	func test_cannot_set_summary():
		var diff = DiffTool.new({},{}, GutUtils.DIFF.DEEP)
		diff.summary = 'the summary'
		assert_push_error('cannot set summary')
		assert_ne(diff.summary,  'the summary')

	func test_summary_prop_returns_summarize():
		var diff = DiffTool.new({},{}, GutUtils.DIFF.DEEP)
		assert_not_null(diff.summary)

	func test_cannot_set_are_equal():
		var diff = DiffTool.new({},{}, GutUtils.DIFF.DEEP)
		diff.are_equal = 'asdf'
		assert_push_error('cannot set are_equal')
		assert_eq(diff.are_equal, true)

	func test_are_equal_prop_returns_result_of_diff():
		var diff = DiffTool.new({},{}, GutUtils.DIFF.DEEP)
		assert_eq(diff.are_equal, true)

	func test_get_different_count_returns_correct_number():
		var diff = DiffTool.new({'a':1, 'b':2, 'c':3}, {'a':'a', 'b':2, 'c':'c'}, GutUtils.DIFF.DEEP)
		assert_eq(diff.get_different_count(), 2)

	func test_get_total_count_returns_correct_number():
		var diff = DiffTool.new({'a':1, 'b':2, 'c':3}, {'aa':9, 'b':2, 'cc':10}, GutUtils.DIFF.DEEP)
		assert_eq(diff.get_total_count(), 5)

	func test_get_short_summary_includes_x_of_y_keys_when_different():
		var diff = DiffTool.new({'a':1, 'b':2, 'c':3}, {'aa':9, 'b':2, 'cc':10}, GutUtils.DIFF.DEEP)
		assert_string_contains(diff.get_short_summary(), '4 of 5')

	func test_get_short_summary_does_not_include_x_of_y_when_equal():
		var diff = DiffTool.new({}, {}, GutUtils.DIFF.DEEP)
		assert_eq(diff.get_short_summary().find(' of '), -1, diff.get_short_summary())
		assert_string_contains(diff.get_short_summary(), '==')

	func test_brackets():
		var diff = DiffTool.new({}, {})
		assert_eq(diff.get_brackets().open, '{', 'open')
		assert_eq(diff.get_brackets().close, '}', 'close')


class TestDictionaryDiff:
	extends GutInternalTester

	var DiffTool = GutUtils.DiffTool

	func test_can_init_with_two_dictionaries():
		var dd = DiffTool.new({}, {})
		assert_not_null(dd)

	func test_constructor_defaults_diff_type_to_deep():
		var diff = DiffTool.new({}, {})
		assert_eq(diff.get_diff_type(), GutUtils.DIFF.DEEP)

	func test_get_differences_returns_empty_array_when_matching():
		var dd = DiffTool.new({'a':'asdf'}, {'a':'asdf'})
		assert_eq(dd.get_differences().keys(), [])

	func test_get_differences_returns_non_matching_keys():
		var dd = DiffTool.new({'a':'asdf', 'b':1}, {'a':'asdf', 'b':2})
		assert_eq(dd.get_differences().keys(), ['b'])

	func test_get_differetn_keys_returns_missing_indexes_in_d2():
		var dd = DiffTool.new({'a':'asdf', 'b':1}, {'a':'asdf'})
		assert_eq(dd.get_differences().keys(), ['b'])

	func test_get_different_keys_returns_missing_indexes_in_d1():
		var dd = DiffTool.new({'a':'asdf'}, {'a':'asdf', 'b':1})
		assert_eq(dd.get_differences().keys(), ['b'])

	func test_get_differences_works_with_different_datatypes():
		var d1 = {'a':1, 'b':'two', 'c':autofree(Node2D.new())}
		var d2 = {'a':1.0, 'b':2, 'c':GutUtils.Strutils.new()}
		var dd = DiffTool.new(d1, d2)
		assert_eq(dd.get_differences().keys(), ['a', 'b', 'c'])

	func test_are_equal_true_for_matching_dictionaries():
		assert_true(DiffTool.new({}, {}).are_equal, 'empty')
		assert_true(DiffTool.new({'a':1}, {'a':1}).are_equal, 'same')
		assert_true(DiffTool.new({'a':1, 'b':2}, {'b':2, 'a':1}).are_equal, 'different order')


	func test_sub_dictionary_compare_when_equal():
		var d1 = {'a':1, 'b':{'a':99}}
		var d2 = {'a':1, 'b':{'a':99}}
		var dd = DiffTool.new(d1, d2)
		assert_true(dd.are_equal, dd.summarize())

	func test_sub_dictionary_compare_when_not_equal():
		var d1 = {'a':1, 'b':{'c':88, 'd':22, 'f':{'g':1, 'h':200}}, 'z':{}, 'dne_in_d2':'asdf'}
		var d2 = {'a':1, 'b':{'c':99, 'e':'letter e', 'f':{'g':1, 'h':2}}, 'z':{}}
		var dd = DiffTool.new(d1, d2)
		assert_false(dd.are_equal, dd.summarize())
		assert_eq(dd.get_total_count(), 4, 'total key count')
		assert_eq(dd.get_different_count(), 2, 'total different count')

	func test_sub_dictionary_missing_in_other():
		var d1 = {'a': 1, 'dne_in_d2':{'x':'x', 'y':'y', 'z':'z'}, 'r':1}
		var d2 = {'a': 2, 'dne_in_d1':{'xx':'x', 'yy':'y', 'zz':'z'}, 'r':2}
		var diff = DiffTool.new(d1, d2)
		var summary = diff.summarize()
		assert_string_contains(summary, 'key>' + ' !=')
		assert_string_contains(summary, ' != ' + '<missing')


	func test_dictionary_key_and_non_dictionary_key():
		var d1 = {'a':1, 'b':{'c':1}}
		var d2 = {'a':1, 'b':22}
		var diff = DiffTool.new(d1, d2)
		assert_false(diff.are_equal, diff.summarize())

	func test_ditionaries_in_arrays():
		var d1 = {'a':[{'b':1}]}
		var d2 = {'a':[{'b':1}]}
		var diff = DiffTool.new(d1, d2)
		assert_true(diff.are_equal, diff.summarize())


	func test_when_deep_diff_then_different_arrays_contains_DiffTool():
		var d1 = {'a':[1, 2, 3]}
		var d2 = {'a':[3, 4, 5]}
		var diff = DiffTool.new(d1, d2, GutUtils.DIFF.DEEP)
		assert_is(diff.differences['a'], GutUtils.DiffTool)


	func test_large_differences_in_sub_arrays_does_not_exceed_max_differences_shown():
		var d1 = {'a':[], 'b':[]}
		var d2 = {'a':[], 'b':[]}
		for i in range(200):
			d1['a'].append(i)
			d2['a'].append(i + 1)

			d1['b'].append(i)
			d2['b'].append(i + 1)

		var diff = DiffTool.new(d1, d2, GutUtils.DIFF.DEEP)
		diff.max_differences = 10
		assert_lt(diff.summary.split("\n").size(), 50, diff.summary)
		assert_false(diff.are_equal)