local suite = require('Module:ScribuntoUnit'):new()

function suite:testAssertTrueWithTrueBoolean()
    self:assertTrue(true)
end

function suite:testAssertTrueWithTruthyValue()
    self:assertTrue(1)
end

function suite:testAssertTrueWithFalsyValue()
    self:assertThrows(function()
        suite:assertTrue(false)
    end)
    self:assertThrows(function()
        suite:assertTrue(nil)
    end)
end

function suite:testAssertFalseWithFalseBoolean()
    self:assertFalse(false)
end

function suite:testAssertFalseWithNil()
    self:assertFalse(nil)
end

function suite:testAssertFalseWithTruthyValue()
    self:assertThrows(function()
        suite:assertFalse(true)
    end)
    self:assertThrows(function()
        suite:assertFalse(1)
    end)
end

function suite:testAssertStringContainsWithPresentSubstring()
    self:assertStringContains('foo', 'foobar')
    self:assertStringContains('foo[', 'foo[bar', true)
end

function suite:testAssertStringContainsWithAbsentSubstring()
    self:assertThrows(function()
        self:assertStringContains('baz', 'foobar')
    end)
    self:assertThrows(function()
        suite:assertStringContains('[qux', 'baz]qux', true)
    end)
end

function suite:testAssertStringContainsWithInvalidParameters()
    self:assertThrows(function()
        self:assertStringContains('foo[', 'foo[bar')
    end)
    self:assertThrows(function()
        suite:assertStringContains('[qux', 'baz]qux')
    end)
end

function suite:testAssertEqualsWithEqualStrings()
    self:assertEquals('abc', 'abc')
end

function suite:testAssertEqualsWithUnequalStrings()
    self:assertThrows(function()
        suite:assertEquals('abc', 'def')
    end)
end

function suite:testAssertWithinDeltaWithInteger()
    self:assertWithinDelta(49, 50, 1e+2)
    self:assertWithinDelta(49.5, 50, 1e+1)
end

function suite:testAssertWithinDeltaWithFloat()
    self:assertWithinDelta(0.2, 0.3 - 0.1, 1e-12)
end

function suite:testAssertDeepEqualsWithEqualTables()
    self:assertDeepEquals({ { 1, 3 }, { 2, 4 } }, { [2] = { 2, 4 }, [1] = { 1, 3 } })
end

function suite:testAssertDeepEqualsWithUnequalTables()
    self:assertThrows(function()
        self:assertDeepEquals({ { 1, 3 }, { 2, 4 } }, { { 2, 4 }, { 1, 3 } })
    end)
end

function suite:testAssertResultEquals()
    self:assertResultEquals('f', '{{#invoke:string|sub|foo|1|1}}')
end

function suite:testAssertSameResult()
    self:assertSameResult('{{#sub:foo|0|1}}', '{{#invoke:string|sub|foo|1|1}}')
end

function suite:testAssertTemplateEquals()
    self:assertTemplateEquals('f', 'string', { 'sub', 'foo', '1', '1' })
end

function suite:testAssertThrows()
    self:assertThrows(error, nil)
    self:assertThrows(function() error('error message') end, 'error message')
end

return suite