/*
Copyright (C) 2015-2016 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License v3 as published by the Free
Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with LiveCode.  If not see <http://www.gnu.org/licenses/>.  */

module com.livecode.arithmetic.tests

public handler TestUnarySigns()
	variable tNum
	put 10 into tNum
	test "unary−" when -tNum is -10

	put -10 into tNum
	test "unary+" when +tNum is -10
end handler

public handler TestAdd()
	variable tInt as Integer
	put 10 into tInt

	add 2 to tInt
	test "add (syntax, int)" when tInt = 12
	test "add (operator, int)" when tInt + 1 = 13

	add 1.9 to tInt
	test diagnostic "Expecting an error"
	broken test "add (syntax, int+real)" when tInt = 13 because "bug 14592"

	variable tReal as Real
	put 10 into tReal
	add 1.9 to tReal

	test "add (syntax, real)" when tReal = 11.9
	test "add (operator, real)" when tReal + 0.2 = 12.1

	variable tNumber
	put 10 into tNumber
	add -1.9 to tNumber

	test "add (syntax, number)" when tNumber = 8.1
	test "add (operator, number)" when tNumber + -1 = 7.1
end handler

public handler TestSubtract()
	variable tInt as Integer
	put 10 into tInt

	subtract 2 from tInt
	test "subtract (syntax, int)" when tInt = 8
	test "subtract (operator, int)" when tInt - -2 = 10

	subtract 1.9 from tInt
	test diagnostic "Expecting an error"
	broken test "subtract (syntax, int-real)" when tInt = 6 because "bug 14592"

	variable tReal as Real
	put 10 into tReal
	subtract 1.9 from tReal

	test "subtract (syntax, real)" when tReal = 8.1
	test "subtract (operator, real)" when tReal - 0.25 = 7.85

	variable tNumber
	put 10 into tNumber
	subtract -1.9 from tNumber

	test "subtract (syntax, number)" when tNumber = 11.9
	test "subtract (operator, number)" when tNumber - 1 = 10.9
end handler

public handler TestMultiply()
	variable tInt as Integer
	put 10 into tInt

	multiply tInt by 2
	test "multiply (syntax, int)" when tInt = 20
	test "multiply (operator, int)" when tInt * 2 = 40

	variable tReal as Real
	put 10 into tReal
	multiply tReal by -0.5
	test "multiply (syntax, real)" when tReal = -5
	test "multiply (operator, real)" when tReal * 3.5 = -17.5

	variable tNumber
	put 10 into tNumber
	multiply tNumber by 0.5
	test "multiply (syntax, number)" when tNumber = 5
	test "multiply (operator, number)" when tNumber * 3.5 = 17.5
end handler

public handler TestDivide()
	variable tInt as Integer
	put 10 into tInt

	divide tInt by 2
	test "divide (syntax, int)" when tInt = 5
	test "divide (operator, int)" when 30 / tInt = 6

	divide tInt by 2
	test diagnostic "Expecting trunc"
	broken test "divide (syntax, int)" when tInt = 2 because "bug 14592"

	variable tReal as Real
	put 10 into tReal
	divide tReal by -0.5
	test "divide (syntax, real)" when tReal = -20
	test "divide (operator, real)" when 50 / tReal = -2.5

	variable tNumber
	put 10 into tNumber
	divide tNumber by 0.5
	test "divide (syntax, number)" when tNumber = 20
	test "divide (operator, number)" when tNumber / 8 = 2.5
end handler

private handler ModInvariantDiagnostic(in pX, in pY, in pZ, in pR)
	test diagnostic pX formatted as string && "mod" && pY formatted as string
	test diagnostic pY formatted as string && "*" && \
		pZ formatted as string && "+" && \
		pR formatted as string && "=" && \
		(pY * pZ + pR) formatted as string
end handler

private handler ModInvariantInteger(in pX as Integer, in pY as Integer) \
		returns Boolean
	variable tZ as Integer
	variable tR as Integer
	put (pX / pY) into tZ
	put (pX mod pY) into tR

	ModInvariantDiagnostic(pX, pY, tZ, tR)
	return (pY * tZ + tR) is pX
end handler

private handler ModInvariantReal(in pX as Real, in pY as Real) \
		returns Boolean
	variable tZ as Real
	variable tR as Real
	put the trunc of (pX / pY) into tZ -- because there is no "div" operator
	put (pX mod pY) into tR

	ModInvariantDiagnostic(pX, pY, tZ, tR)
	return (pY * tZ + tR) is pX
end handler

public handler TestModInteger()
	broken test "mod int (+ve, +ve)" when ModInvariantInteger(10, 3) because "bug 14592"
	broken test "mod (-ve, +ve)" when ModInvariantInteger(-10, 3) because "bug 14592"
	broken test "mod int (+ve, -ve)" when ModInvariantInteger(10, -3) because "bug 14592"
	broken test "mod int (-ve, -ve)" when ModInvariantInteger(-10, -3) because "bug 14592"

	test "mod real (+ve, +ve)" when ModInvariantReal(16, 3.75)
	test "mod real (-ve, +ve)" when ModInvariantReal(-16, 3.75) 
	test "mod real (+ve, -ve)" when ModInvariantReal(16, -3.75)
	test "mod real (-ve, -ve)" when ModInvariantReal(-16, -3.75)
end handler

public handler TestWrap()
	test "wrap (+ve, +ve)" when 5 wrap 3 = 2
	test "wrap (+ve, -ve)" when 5 wrap -3 = 2
	test "wrap (-ve, -ve)" when -5 wrap -3 = -2
	test "wrap (-ve, +ve)" when -5 wrap 3 = -2
end handler

public handler TestGreaterThan()
	test "> (int, real)" when 5.1 > 5
	test "> (real, int)" when -5 > -5.1
	test "> (equal)" when not 5.0 > 5
	test "not > (int, real)" when not 5.1 > 6
	test "not > (real, int)" when not -6 > -5.1
end handler

public handler TestGreaterThanEqual()
	test ">= (int, real)" when 5.1 >= 5
	test ">= (real, int)" when -5 >= -5.1
	test ">= (equal)" when 5.0 >= 5
	test "not >= (int, real)" when not 5.1 >= 6
	test "not >= (real, int)" when not -6 >= -5.1
end handler

public handler TestLessThan()
	test "not < (int, real)" when not 5.1 < 5
	test "not < (real, int)" when not -5 < -5.1
	test "< (equal)" when not 5.0 < 5
	test "< (int, real)" when 5.1 < 6
	test "< (real, int)" when -6 < -5.1
end handler

public handler TestLessThanEqual()
	test "not <= (int, real)" when not 5.1 <= 5
	test "not <= (real, int)" when not -5 <= -5.1
	test "<= (equal)" when 5.0 <= 5
	test "<= (int, real)" when 5.1 <= 6
	test "<= (real, int)" when -6 <= -5.1
end handler

public handler TestFormatString()
	test "formatted as string (int)" when (-1) formatted as string is "-1"

	test "formatted as string (real)" when (-1.1) formatted as string is "-1.1"

	variable tString as String

	format -1 as string into tString
	test "format as string (int)" when tString is "-1"

	format -1.1 as string into tString
	test "format as string (real)" when tString is "-1.1"
end handler

public handler TestParseString()
	test "parsed (int)" when "-1" parsed as number = -1
	test "parsed (real)" when "+1.1" parsed as number = 1.1
	test "parsed (nothing)" when "x" parsed as number is nothing

	parse "-1" as number
	test "parse (int)" when the result is -1
	parse "+1.1" as number
	test "parse (real)" when the result is 1.1
	parse "x" as number
	test "parse (nothing)" when the result is nothing
end handler

public handler TestParseStringList()
	test "parsed list" when ["-1", "+2.2"] parsed as list of number is [-1, 2.2]

	variable tList
	parse ["-1", "+2.2", "x"] as list of number
	put the result into tList

	test "parse list (defined)" when element 1 to 2 of tList is [-1, 2.2]
	test "parse list (nothing)" when element 3 of tList is nothing
end handler

end module