# GdUnit generated TestSuite
extends GdUnitTestSuite

# TestSuite generated from
const __source = 'res://addons/gdUnit4/src/asserts/GdUnitDictionaryAssertImpl.gd'


func test_must_fail_has_invlalid_type() -> void:
	assert_failure(func(): assert_dict(1)) \
		.is_failed() \
		.has_message("GdUnitDictionaryAssert inital error, unexpected type <int>")
	assert_failure(func(): assert_dict(1.3)) \
		.is_failed() \
		.has_message("GdUnitDictionaryAssert inital error, unexpected type <float>")
	assert_failure(func(): assert_dict(true)) \
		.is_failed() \
		.has_message("GdUnitDictionaryAssert inital error, unexpected type <bool>")
	assert_failure(func(): assert_dict("abc")) \
		.is_failed() \
		.has_message("GdUnitDictionaryAssert inital error, unexpected type <String>")
	assert_failure(func(): assert_dict([])) \
		.is_failed() \
		.has_message("GdUnitDictionaryAssert inital error, unexpected type <Array>")
	assert_failure(func(): assert_dict(Resource.new())) \
		.is_failed() \
		.has_message("GdUnitDictionaryAssert inital error, unexpected type <Object>")


func test_is_null() -> void:
	assert_dict(null).is_null()

	assert_failure(func(): assert_dict({}).is_null()) \
		.is_failed() \
		.has_message("Expecting: '<null>' but was '{ }'")


func test_is_not_null() -> void:
	assert_dict({}).is_not_null()

	assert_failure(func(): assert_dict(null).is_not_null()) \
		.is_failed() \
		.has_message("Expecting: not to be '<null>'")


func test_is_equal() -> void:
	assert_dict({}).is_equal({})
	assert_dict({1:1}).is_equal({1:1})
	assert_dict({1:1, "key_a": "value_a"}).is_equal({1:1, "key_a": "value_a" })
	# different order is also equals
	assert_dict({"key_a": "value_a", 1:1}).is_equal({1:1, "key_a": "value_a" })

	# should fail
	assert_failure(func(): assert_dict(null).is_equal({1:1})) \
		.is_failed() \
		.has_message("""
			Expecting:
			 '{
				1: 1
			  }'
			 but was
			 '<null>'"""
			.dedent()
			.trim_prefix("\n")
		)
	assert_failure(func(): assert_dict({}).is_equal({1:1})).is_failed()
	assert_failure(func(): assert_dict({1:1}).is_equal({})).is_failed()
	assert_failure(func(): assert_dict({1:1}).is_equal({1:2})).is_failed()
	assert_failure(func(): assert_dict({1:2}).is_equal({1:1})).is_failed()
	assert_failure(func(): assert_dict({1:1}).is_equal({1:1, "key_a": "value_a"})).is_failed()
	assert_failure(func(): assert_dict({1:1, "key_a": "value_a"}).is_equal({1:1})).is_failed()
	assert_failure(func(): assert_dict({1:1, "key_a": "value_a"}).is_equal({1:1, "key_b": "value_b"})).is_failed()
	assert_failure(func(): assert_dict({1:1, "key_b": "value_b"}).is_equal({1:1, "key_a": "value_a"})).is_failed()
	assert_failure(func(): assert_dict({"key_a": "value_a", 1:1}).is_equal({1:1, "key_b": "value_b"})).is_failed()
	assert_failure(func(): assert_dict({1:1, "key_b": "value_b"}).is_equal({"key_a": "value_a", 1:1})) \
		.is_failed() \
		.has_message("""
			Expecting:
			 '{
				1: 1,
				"key_a": "value_a"
			  }'
			 but was
			 '{
				1: 1,
				"key_ab": "value_ab"
			  }'"""
			.dedent()
			.trim_prefix("\n")
		)


func test_is_not_equal() -> void:
	assert_dict(null).is_not_equal({})
	assert_dict({}).is_not_equal(null)
	assert_dict({}).is_not_equal({1:1})
	assert_dict({1:1}).is_not_equal({})
	assert_dict({1:1}).is_not_equal({1:2})
	assert_dict({2:1}).is_not_equal({1:1})
	assert_dict({1:1}).is_not_equal({1:1, "key_a": "value_a"})
	assert_dict({1:1, "key_a": "value_a"}).is_not_equal({1:1})
	assert_dict({1:1, "key_a": "value_a"}).is_not_equal({1:1,  "key_b": "value_b"})

	# should fail
	assert_failure(func(): assert_dict({}).is_not_equal({})).is_failed()
	assert_failure(func(): assert_dict({1:1}).is_not_equal({1:1})).is_failed()
	assert_failure(func(): assert_dict({1:1, "key_a": "value_a"}).is_not_equal({1:1, "key_a": "value_a"})).is_failed()
	assert_failure(func(): assert_dict({"key_a": "value_a", 1:1}).is_not_equal({1:1, "key_a": "value_a"})) \
		.is_failed() \
		.has_message("""
			Expecting:
			 '{
				1: 1,
				"key_a": "value_a"
			  }'
			 not equal to
			 '{
				1: 1,
				"key_a": "value_a"
			  }'"""
			.dedent()
			.trim_prefix("\n")
		)


func test_is_same() -> void:
	var dict_a := {}
	var dict_b := {"key"="value", "key2"="value"}
	var dict_c := {1:1, "key_a": "value_a"}
	var dict_d := {"key_a": "value_a", 1:1}
	assert_dict(dict_a).is_same(dict_a)
	assert_dict(dict_b).is_same(dict_b)
	assert_dict(dict_c).is_same(dict_c)
	assert_dict(dict_d).is_same(dict_d)

	assert_failure( func(): assert_dict({}).is_same({})) \
		.is_failed()\
		.has_message("""
			Expecting:
			 '{ }'
			 to refer to the same object
			 '{ }'"""
			.dedent()
			.trim_prefix("\n")
		)
	assert_failure( func(): assert_dict({1:1, "key_a": "value_a"}).is_same({1:1, "key_a": "value_a" })) \
		.is_failed()\
		.has_message("""
			Expecting:
			 '{
				1: 1,
				"key_a": "value_a"
			  }'
			 to refer to the same object
			 '{
				1: 1,
				"key_a": "value_a"
			  }'"""
			.dedent()
			.trim_prefix("\n")
		)


func test_is_not_same() -> void:
	var dict_a := {}
	var dict_b := {}
	var dict_c := {1:1, "key_a": "value_a"}
	var dict_d := {1:1, "key_a": "value_a"}
	assert_dict(dict_a).is_not_same(dict_b).is_not_same(dict_c).is_not_same(dict_d)
	assert_dict(dict_b).is_not_same(dict_a).is_not_same(dict_c).is_not_same(dict_d)
	assert_dict(dict_c).is_not_same(dict_a).is_not_same(dict_b).is_not_same(dict_d)
	assert_dict(dict_d).is_not_same(dict_a).is_not_same(dict_b).is_not_same(dict_c)

	assert_failure( func(): assert_dict(dict_a).is_not_same(dict_a)) \
		.is_failed()\
		.has_message("""
			Expecting not same:
			 '{ }'"""
			.dedent()
			.trim_prefix("\n")
		)
	assert_failure( func(): assert_dict(dict_c).is_not_same(dict_c)) \
		.is_failed()\
		.has_message("""
			Expecting not same:
			 '{
				1: 1,
				"key_a": "value_a"
			  }'"""
			.dedent()
			.trim_prefix("\n")
		)


func test_is_empty() -> void:
	assert_dict({}).is_empty()

	assert_failure(func(): assert_dict(null).is_empty()) \
		.is_failed() \
		.has_message("Expecting:\n"
			+ " must be empty but was\n"
			+ " '<null>'")
	assert_failure(func(): assert_dict({1:1}).is_empty()) \
		.is_failed() \
		.has_message("""
			Expecting:
			 must be empty but was
			 '{
				1: 1
			  }'"""
			.dedent()
			.trim_prefix("\n")
		)


func test_is_not_empty() -> void:
	assert_dict({1:1}).is_not_empty()
	assert_dict({1:1, "key_a": "value_a"}).is_not_empty()

	assert_failure(func(): assert_dict(null).is_not_empty()) \
		.is_failed() \
		.has_message("Expecting:\n"
			+ " must not be empty")
	assert_failure(func(): assert_dict({}).is_not_empty()).is_failed()


func test_has_size() -> void:
	assert_dict({}).has_size(0)
	assert_dict({1:1}).has_size(1)
	assert_dict({1:1, 2:1}).has_size(2)
	assert_dict({1:1, 2:1, 3:1}).has_size(3)

	assert_failure(func(): assert_dict(null).has_size(0))\
		.is_failed() \
		.has_message("Expecting: not to be '<null>'")
	assert_failure(func(): assert_dict(null).has_size(1)).is_failed()
	assert_failure(func(): assert_dict({}).has_size(1)).is_failed()
	assert_failure(func(): assert_dict({1:1}).has_size(0)).is_failed()
	assert_failure(func(): assert_dict({1:1}).has_size(2)) \
		.is_failed() \
		.has_message("""
			Expecting size:
			 '2'
			 but was
			 '1'"""
			.dedent()
			.trim_prefix("\n")
		)

class TestObj:
	var _name :String
	var _value :int

	func _init(name :String = "Foo", value :int = 0):
		_name = name
		_value = value

	func _to_string() -> String:
		return "class:%s:%d" % [_name, _value]


func test_contains_keys() -> void:
	var key_a := TestObj.new()
	var key_b := TestObj.new()
	var key_c := TestObj.new()
	var key_d := TestObj.new("D")

	assert_dict({1:1, 2:2, 3:3}).contains_keys([2])
	assert_dict({1:1, 2:2, "key_a": "value_a"}).contains_keys([2, "key_a"])
	assert_dict({key_a:1, key_b:2, key_c:3}).contains_keys([key_a, key_b])
	assert_dict({key_a:1, key_c:3 }).contains_keys([key_b])
	assert_dict({key_a:1, 3:3}).contains_keys([key_a, key_b])


	assert_failure(func(): assert_dict({1:1, 3:3}).contains_keys([2])) \
		.is_failed() \
		.has_message("""
			Expecting contains keys:
			 '[1, 3]'
			 to contains:
			 '[2]'
			 but can't find key's:
			 '[2]'"""
			.dedent()
			.trim_prefix("\n")
		)
	assert_failure(func(): assert_dict({1:1, 3:3}).contains_keys([1, 4])) \
		.is_failed() \
		.has_message("""
			Expecting contains keys:
			 '[1, 3]'
			 to contains:
			 '[1, 4]'
			 but can't find key's:
			 '[4]'"""
			.dedent()
			.trim_prefix("\n")
		)
	assert_failure(func(): assert_dict(null).contains_keys([1, 4])) \
		.is_failed() \
		.has_message("Expecting: not to be '<null>'")
	assert_failure(func(): assert_dict({key_a:1, 3:3}).contains_keys([key_a, key_d])) \
		.is_failed() \
		.has_message("""
			 Expecting contains keys:
			  '[class:Foo:0, 3]'
			  to contains:
			  '[class:Foo:0, class:D:0]'
			  but can't find key's:
			  '[class:D:0]'"""
			.dedent().trim_prefix("\n"))


func test_contains_key_value() -> void:
	assert_dict({1:1}).contains_key_value(1, 1)
	assert_dict({1:1, 2:2, 3:3}).contains_key_value(3, 3).contains_key_value(1, 1)

	assert_failure(func(): assert_dict({1:1}).contains_key_value(1, 2)) \
		.is_failed() \
		.has_message("""
			Expecting contains key and value:
			 '1' : '2'
			 but contains
			 '1' : '1'"""
			.dedent()
			.trim_prefix("\n")
		)
	assert_failure(func(): assert_dict(null).contains_key_value(1, 2)) \
		.is_failed() \
		.has_message("Expecting: not to be '<null>'")


func test_not_contains_keys() -> void:
	assert_dict({}).not_contains_keys([2])
	assert_dict({1:1, 3:3}).not_contains_keys([2])
	assert_dict({1:1, 3:3}).not_contains_keys([2, 4])

	assert_failure(func(): assert_dict({1:1, 2:2, 3:3}).not_contains_keys([2, 4])) \
		.is_failed() \
		.has_message("""
			Expecting NOT contains keys:
			 '[1, 2, 3]'
			 do not contains:
			 '[2, 4]'
			 but contains key's:
			 '[2]'"""
			.dedent()
			.trim_prefix("\n")
		)
	assert_failure(func(): assert_dict({1:1, 2:2, 3:3}).not_contains_keys([1, 2, 3, 4])) \
		.is_failed() \
		.has_message("""
			Expecting NOT contains keys:
			 '[1, 2, 3]'
			 do not contains:
			 '[1, 2, 3, 4]'
			 but contains key's:
			 '[1, 2, 3]'"""
			.dedent()
			.trim_prefix("\n")
		)
	assert_failure(func(): assert_dict(null).not_contains_keys([1, 4])) \
		.is_failed() \
		.has_message("Expecting: not to be '<null>'")


func test_contains_same_keys() -> void:
	var key_a := TestObj.new()
	var key_b := TestObj.new()
	var key_c := TestObj.new()

	assert_dict({1:1, 2:2, 3:3}).contains_same_keys([2])
	assert_dict({1:1, 2:2, "key_a": "value_a"}).contains_same_keys([2, "key_a"])
	assert_dict({key_a:1, key_b:2, 3:3}).contains_same_keys([key_b])
	assert_dict({key_a:1, key_b:2, 3:3}).contains_same_keys([key_a, key_b])

	assert_failure(func(): assert_dict({key_a:1, key_c:3 }).contains_same_keys([key_a, key_b])) \
		.is_failed() \
		.has_message("""
			Expecting contains SAME keys:
			 '[class:Foo:0, class:Foo:0]'
			 to contains:
			 '[class:Foo:0, class:Foo:0]'
			 but can't find key's:
			 '[class:Foo:0]'"""
			.dedent().trim_prefix("\n")
		)


func test_contains_same_key_value() -> void:
	var key_a := TestObj.new("A")
	var key_b := TestObj.new("B")
	var key_c := TestObj.new("C")
	var key_d := TestObj.new("A")

	assert_dict({key_a:1, key_b:2, key_c:3})\
		.contains_same_key_value(key_a, 1)\
		.contains_same_key_value(key_b, 2)

	assert_failure(func(): assert_dict({key_a:1, key_b:2, key_c:3}).contains_same_key_value(key_a, 2)) \
		.is_failed() \
		.has_message("""
			Expecting contains SAME key and value:
			 <class:A:0> : '2'
			 but contains
			 <class:A:0> : '1'"""
			.dedent().trim_prefix("\n")
		)
	assert_failure(func(): assert_dict({key_a:1, key_b:2, key_c:3}).contains_same_key_value(key_d, 1)) \
		.is_failed() \
		.has_message("""
			Expecting contains SAME key and value:
			 <class:A:0> : '1'
			 but contains
			 <class:A:0> : '[class:A:0, class:B:0, class:C:0]'"""
			.dedent().trim_prefix("\n")
		)


func test_not_contains_same_keys() -> void:
	var key_a := TestObj.new("A")
	var key_b := TestObj.new("B")
	var key_c := TestObj.new("C")
	var key_d := TestObj.new("A")

	assert_dict({}).not_contains_same_keys([key_a])
	assert_dict({key_a:1, key_b:2}).not_contains_same_keys([key_c, key_d])

	assert_failure(func(): assert_dict({key_a:1, key_b:2}).not_contains_same_keys([key_c, key_b])) \
		.is_failed() \
		.has_message("""
			Expecting NOT contains SAME keys
			 '[class:A:0, class:B:0]'
			 do not contains:
			 '[class:C:0, class:B:0]'
			 but contains key's:
			 '[class:B:0]'"""
			.dedent().trim_prefix("\n")
		)


func test_override_failure_message() -> void:
	assert_failure(func(): assert_dict({1:1}) \
			.override_failure_message("Custom failure message") \
			.is_null()) \
		.is_failed() \
		.has_message("Custom failure message")


# tests if an assert fails the 'is_failure' reflects the failure status
func test_is_failure() -> void:
	# initial is false
	assert_bool(is_failure()).is_false()

	# checked success assert
	assert_dict({}).is_empty()
	assert_bool(is_failure()).is_false()

	# checked faild assert
	assert_failure(func(): assert_dict({}).is_not_empty()).is_failed()
	assert_bool(is_failure()).is_true()

	# checked next success assert
	assert_dict({}).is_empty()
	# is true because we have an already failed assert
	assert_bool(is_failure()).is_true()

	# should abort here because we had an failing assert
	if is_failure():
		return
	assert_bool(true).override_failure_message("This line shold never be called").is_false()