/*
Copyright (C) 2015 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.list.tests

use com.livecode.list
use com.livecode.__INTERNAL._testlib

public handler TestEmpty()
	variable tList
	put the empty list into tList
	test "empty (empty)" when tList is empty
	test "empty (empty list)" when tList is the empty list
	test "empty (empty literal)" when tList is []
	test "empty (no elements)" when the number of elements in tList is 0
end handler

public handler TestLiteral()
	variable tList
	put [[], "x", 1, true] into tList
	test "literal" when the number of elements in tList is 4
end handler

public handler TestIs()
	test "is" when [[], "x", 1, true] is [[], "x", 1, true]
	test "is not" when [[], "x", 1, true] is not [[1], "x", 1, true]
end handler

handler TestHead_Empty()
	return the head of []
end handler
handler TestHead_FirstEmpty()
	return the first element of []
end handler
public handler TestHead()
	variable tList
	put ["x", 1, true] into tList

	test "head" when the head of tList is "x"
	test "first" when the first element of tList is "x"

	MCUnitTestHandlerThrows(TestHead_Empty, "head (empty)")
	MCUnitTestHandlerThrows(TestHead_FirstEmpty, "first (empty)")
end handler

handler TestTail_Empty()
	return the tail of []
end handler
handler TestTail_LastEmpty()
	return the last element of []
end handler
public handler TestTail()
	variable tList
	put ["x", 1, true] into tList
	test "tail" when the tail of tList
	test "last" when the last element of tList

	MCUnitTestHandlerThrows(TestTail_Empty, "tail (empty)")
	MCUnitTestHandlerThrows(TestTail_LastEmpty, "last (empty)")
end handler

public handler TestPush()
	variable tList
	put ["x", 1, true] into tList

	push "y" onto tList
	test "push" when the tail of tList is "y"

	push "z" onto front of tList
	test "push front" when the head of tList is "z"

	push "w" onto back of tList
	test "push back" when the tail of tList is "w"

	test "push (result)" when tList is ["z", "x", 1, true, "y", "w"]
end handler

handler TestPop_Empty()
	variable tList
	put [] into tList
	pop tList
end handler
handler TestPop_FrontEmpty()
	variable tList
	put [] into tList
	pop front of tList
end handler
handler TestPop_BackEmpty()
	variable tList
	put [] into tList
	pop back of tList
end handler
public handler TestPop()
	variable tList
	variable tPopped

	put ["x", 1, 2, true] into tList

	pop tList into tPopped
	test "pop" when tPopped

	pop front of tList into tPopped
	test "pop front" when tPopped is "x"

	pop back of tList into tPopped
	test "pop back" when tPopped is 2

	test "pop (result)" when tList is [1]

	pop tList
	test "pop (no output)" when tList is empty

	MCUnitTestHandlerThrows(TestPop_Empty, "pop (empty)")
	MCUnitTestHandlerThrows(TestPop_FrontEmpty, "pop front (empty)")
	MCUnitTestHandlerThrows(TestPop_BackEmpty, "pop back (empty)")
end handler

public handler TestCount()
	test "count" when the number of elements in [1, 2, ["a", "b"]] is 3
end handler

public handler TestContainsELement()
	variable tList
	put ["x", 1, true] into tList
	test "element is in" when "x" is in tList
	test "element is not in" when not [] is in tList
end handler

public handler TestContainsList()
	variable tList
	put ["x", 1, true, []] into tList
	test "contains" when tList contains ["x", 1]

	test "contains (missing)" when not tList contains [1, "x"]
	test "contains (empty)" when not [] contains []

	-- Bug 14596
	test "contains (missing, overlap)" when not ["x", 1, true, ""] contains ["", true]
end handler

public handler TestBeginsWith()
	variable tList
	put ["x", 1, true, []] into tList
	test "begins with" when tList begins with ["x", 1]
	test "begins with (missing)" when not tList begins with [1, true]
	test "begins with (empty)" when tList begins with []
end handler

public handler TestEndsWith()
	variable tList
	put ["x", 1, true, []] into tList
	test "ends with" when tList ends with [true, []]
	test "ends with (missing)" when not tList ends with [1, true]
	test "ends with (empty)" when tList ends with []
end handler

handler TestSubscript_Zero()
	return [1][0]
end handler
handler TestSubscript_Empty()
	return [][1]
end handler
handler TestSubscript_After()
	return[1][2]
end handler
handler TestSubscript_Before()
	return[1][-2]
end handler
public handler TestSubscript()
	variable tList
	put ["x", 1, true, []] into tList
	test "subscript (syntax, +ve)" when element 2 of tList is 1
	test "subscript (syntax, -ve)" when element -2 of tList is true
	test "subscript (operator, +ve)" when tList[4] is []
	test "subscript (operator, -ve)" when tList[-4] is "x"
	test "subscript (operator literal)" when [4][1] is 4

	MCUnitTestHandlerThrows(TestSubscript_Zero, "subscript (operator, zero)")
	MCUnitTestHandlerThrows(TestSubscript_Empty, "subscript (operator, empty)")
	MCUnitTestHandlerThrows(TestSubscript_After, "subscript (operator, after)")
	MCUnitTestHandlerThrows(TestSubscript_Before, "subscript (operator, before)")
end handler

handler TestRange_Zero()
	return element 0 to 0 of [1]
end handler
handler TestRange_Before()
	variable tList
	put element -4 to -3 of ["x", 1, true] into tList
end handler
handler TestRange_After()
	return element 3 to 4 of ["x", 1, true]
end handler
public handler TestRange()
	variable tList
	put ["x", 1, true, []] into tList
	test "range (+ve)" when element 2 to 3 of tList is [1, true]
	test "range (+ve, same)" when element 2 to 2 of tList is [1]
	test "range (-ve)" when element -3 to -2 of tList is [1, true]
	test "range (-ve, same)" when element -2 to -2 of tList is [true]

	MCUnitTestHandlerThrows(TestRange_Zero, "range (zero)")
	MCUnitTestHandlerThrows(TestRange_After, "range (after)")
	MCUnitTestHandlerThrows(TestRange_Before, "range (before)")
end handler

handler TestDeleteSingle_Zero()
	variable tList
	put ["x", 1, true, []] into tList
	delete element 0 of tList
end handler
handler TestDeleteSingle_Before()
	variable tList
	put ["x", 1, true, []] into tList
	delete element -5 of tList
end handler
handler TestDeleteSingle_After()
	variable tList
	put ["x", 1, true, []] into tList
	delete element 5 of tList
end handler
public handler TestDeleteSingle()
	variable tList
	variable tTemplate
	put ["x", 1, true, []] into tTemplate

	put tTemplate into tList
	delete element 3 of tList
	test "delete single (+ve)" when tList is ["x", 1, []]

	put tTemplate into tList
	delete element -3 of tList
	test "delete single (-ve)" when tList is ["x", true, []]

	put tTemplate into tList
	delete the first element of tList
	test "delete first" when tList is [1, true, []]

	put tTemplate into tList
	delete the last element of tList
	test "delete last" when tList is ["x", 1, true]

	MCUnitTestHandlerThrows(TestDeleteSingle_Zero, "delete single (zero)")
	MCUnitTestHandlerThrows(TestDeleteSingle_Before, "delete single (before)")
	MCUnitTestHandlerThrows(TestDeleteSingle_After, "delete single (after)")
end handler

handler TestDeleteRange_Zero()
	variable tList
	put ["x", 1, true, []] into tList
	delete element 0 to 0 of tList
end handler
handler TestDeleteRange_Before()
	variable tList
	put ["x", 1, true, []] into tList
	delete element -5 to -4 of tList
end handler
handler TestDeleteRange_After()
	variable tList
	put ["x", 1, true, []] into tList
	delete element 4 to 5 of tList
end handler
public handler TestDeleteRange()
	variable tList
	variable tTemplate
	put ["x", 1, true, []] into tTemplate

	put tTemplate into tList
	delete element 2 to 3 of tList
	test "delete range (+ve)" when tList is ["x", []]

	put tTemplate into tList
	delete element -3 to -2 of tList
	test "delete range (-ve)" when tList is ["x", []]

	MCUnitTestHandlerThrows(TestDeleteRange_Zero, "delete range (zero)")
	MCUnitTestHandlerThrows(TestDeleteRange_Before, "delete range (before)")
	MCUnitTestHandlerThrows(TestDeleteRange_After, "delete range (after)")
end handler

public handler TestSplice()
	variable tList
	variable tTemplate
	put [1, 1, 1, 1] into tTemplate

	put tTemplate into tList
	splice [2, 2] into element 2 to 3 of tList
	test "splice (+ve)" when tList is [1, 2, 2, 1]

	put tTemplate into tList
	splice [2, 2] into element -3 to -2 of tList
	test "splice (-ve)" when tList is [1, 2, 2, 1]

	put tTemplate into tList
	splice [2, 2] into element 2 to 2 of tList
	test "splice (+ve, same)" when tList is [1, 2, 2, 1, 1]

	put tTemplate into tList
	splice [2, 2] into element 2 of tList
	test "splice (+ve, single)" when tList is [1, 2, 2, 1, 1]

	put tTemplate into tList
	splice the empty list into element 1 to 4 of tList
	test "splice (+ve, empty)" when tList is empty
end handler

handler TestSpliceBefore_Zero()
	variable tList
	put [1] into tList
	splice tList before element 0 of tList
end handler

handler TestSpliceAfter_Limit()
	variable tList
	put [1] into tList
	splice tList after element 2 of tList
end handler

public handler TestSpliceBefore()
	variable tList
	variable tTemplate
	put [1, 1, 1, 1] into tTemplate

	put tTemplate into tList
	splice [2, 2] before element 2 of tList
	test "splice before" when tList is [1, 2, 2, 1, 1, 1]

	put tTemplate into tList
	splice the empty list before element 2 of tList
	test "splice before (empty)" when tList is tTemplate
	
	MCUnitTestHandlerThrows(TestSpliceBefore_Zero, "splice before (zero)")
end handler

public handler TestSpliceAfter()
	variable tList
	variable tTemplate
	put [1, 1, 1, 1] into tTemplate

	put tTemplate into tList
	splice [2, 2] after element 2 of tList
	test "splice after" when tList is [1, 1, 2, 2, 1, 1]

	put tTemplate into tList
	splice the empty list after element 2 of tList
	test "splice after (empty)" when tList is tTemplate
	
	MCUnitTestHandlerThrows(TestSpliceAfter_Limit, "splice after (limit)")
end handler

public handler TestRepeatElement()
	variable tIter
	variable tCount

	put 0 into tCount

	repeat for each element tIter in [1, 1, 1, 1]
		test "repeat element (iter)" when tIter is 1
		add 1 to tCount
	end repeat

	test "repeat element (count)" when tCount is 4
end handler

----------------------------------------------------------------
-- Finding indices
----------------------------------------------------------------

public handler TestIndex()
	variable tList
	put ["x", 1, true, [], []] into tList

	test "index" when the index of 1 in tList is 2
	test "index (list)" when the index of [] in tList is 4
	test "index (missing)" when the index of false in tList is 0

	test "first index" when the first index of [] in tList is 4
	test "last index" when the last index of [] in tList is 5

	test "index (empty)" when the index of 1 in [] is 0
end handler

----------------------------------------------------------------

handler TestIndexAfter_InvalidPositive()
	return the index of true after 2 in [true]
end handler
handler TestIndexAfter_InvalidNegative()
	return the index of true after -3 in [true]
end handler
handler TestFirstIndexAfter_InvalidPositive()
	return the first index of true after 2 in [true]
end handler
handler TestFirstIndexAfter_InvalidNegative()
	return the first index of true after -3 in [true]
end handler
handler TestLastIndexAfter_InvalidPositive()
	return the last index of true after 2 in [true]
end handler
handler TestLastIndexAfter_InvalidNegative()
	return the last index of true after -3 in [true]
end handler
public handler TestIndexAfter()
	variable tList
	put [true, false, true, true, false] into tList

	test "index after (+ve)" when the index of true after 1 in tList is 3
	test "index after (-ve)" when the index of true after -5 in tList is 3
	test "index after (-ve, limit)" when the index of true after -6 in tList is 1
	test "index after (+ve, missing)" when the index of true after 4 in tList is 0
	test "index after (-ve, missing)" when the index of true after -2 in tList is 0

	MCUnitTestHandlerThrows(TestIndexAfter_InvalidPositive, "index after (+ve, invalid)")
	MCUnitTestHandlerThrows(TestIndexAfter_InvalidNegative, "index after (-ve, invalid)")
end handler
public handler TestFirstIndexAfter()
	variable tList
	put [true, false, true, true, false] into tList

	test "first index after (+ve)" when the first index of true after 1 in tList is 3
	test "first index after (-ve)" when the first index of true after -5 in tList is 3
	test "first index after (-ve, limit)" when the first index of true after -6 in tList is 1
	test "first index after (+ve, missing)" when the first index of true after 4 in tList is 0
	test "first index after (-ve, missing)" when the first index of true after -2 in tList is 0

	MCUnitTestHandlerThrows(TestFirstIndexAfter_InvalidPositive, "first index after (+ve, invalid)")
	MCUnitTestHandlerThrows(TestFirstIndexAfter_InvalidNegative, "first index after (-ve, invalid)")
end handler
public handler TestLastIndexAfter()
	variable tList
	put [true, false, true, true, false] into tList

	test "last index after (+ve)" when the last index of true after 1 in tList is 4
	test "last index after (-ve)" when the last index of true after -5 in tList is 4
	test "last index after (-ve, limit)" when the last index of true after -6 in tList is 4
	test "last index after (+ve, missing)" when the last index of true after 4 in tList is 0
	test "last index after (-ve, missing)" when the last index of true after -2 in tList is 0

	MCUnitTestHandlerThrows(TestLastIndexAfter_InvalidPositive, "last index after (+ve, invalid)")
	MCUnitTestHandlerThrows(TestLastIndexAfter_InvalidNegative, "last index after (-ve, invalid)")
end handler
public handler TestIndexAfterZero()
	-- "index of _ after 0 in _" should be equivalent to "index of _ in _"
	variable tList
	put [true, false, true, true, false] into tList
	variable tNoAfter

	put the index of true in tList into tNoAfter
	test "index after (+ve, 0)" when the index of true after 0 in tList is tNoAfter

	put the first index of true in tList into tNoAfter
	test "first index after (+ve, 0)" when the first index of true after 0 in tList is tNoAfter

	put the last index of true in tList into tNoAfter
	test "last index after (+ve, 0)" when the last index of true after 0 in tList is tNoAfter
end handler

----------------------------------------------------------------

handler TestIndexBefore_InvalidPositive()
	return the index of true before 3 in [true]
end handler
handler TestIndexBefore_InvalidNegative()
	return the index of true before -2 in [true]
end handler
handler TestFirstIndexBefore_InvalidPositive()
	return the first index of true before 3 in [true]
end handler
handler TestFirstIndexBefore_InvalidNegative()
	return the first index of true before -2 in [true]
end handler
handler TestLastIndexBefore_InvalidPositive()
	return the last index of true before 3 in [true]
end handler
handler TestLastIndexBefore_InvalidNegative()
	return the last index of true before -2 in [true]
end handler
public handler TestIndexBefore()
	variable tList
	put [false, true, true, false, true] into tList

	test "index before (+ve)" when the index of true before 4 in tList is 3
	test "index before (-ve)" when the index of true before -2 in tList is 3
	test "index before (+ve, limit)" when the index of true before 6 in tList is 5
	test "index before (+ve, missing)" when the index of true before 2 in tList is 0
	test "index before (-ve, missing)" when the index of true before -4 in tList is 0

	MCUnitTestHandlerThrows(TestIndexBefore_InvalidPositive, "index before (+ve, invalid)")
	MCUnitTestHandlerThrows(TestIndexBefore_InvalidNegative, "index before (-ve, invalid)")
end handler
public handler TestFirstIndexBefore()
	variable tList
	put [false, true, true, false, true] into tList

	test "first index before (+ve)" when the first index of true before 4 in tList is 2
	test "first index before (-ve)" when the first index of true before -2 in tList is 2
	test "first index before (+ve, limit)" when the first index of true before 6 in tList is 2
	test "first index before (+ve, missing)" when the first index of true before 2 in tList is 0
	test "first index before (-ve, missing)" when the first index of true before -4 in tList is 0

	MCUnitTestHandlerThrows(TestFirstIndexBefore_InvalidPositive, "first index before (+ve, invalid)")
	MCUnitTestHandlerThrows(TestFirstIndexBefore_InvalidNegative, "first index before (-ve, invalid)")
end handler
public handler TestLastIndexBefore()
	variable tList
	put [false, true, true, false, true] into tList

	test "last index before (+ve)" when the last index of true before 4 in tList is 3
	test "last index before (-ve)" when the last index of true before -2 in tList is 3
	test "last index before (+ve, limit)" when the last index of true before 6 in tList is 5
	test "last index before (+ve, missing)" when the last index of true before 2 in tList is 0
	test "last index before (-ve, missing)" when the last index of true before -4 in tList is 0

	MCUnitTestHandlerThrows(TestLastIndexBefore_InvalidPositive, "last index before (+ve, invalid)")
	MCUnitTestHandlerThrows(TestLastIndexBefore_InvalidNegative, "last index before (-ve, invalid)")
end handler
public handler TestIndexBeforeZero()
	-- "index of _ before 0 in _" should be equivalent to
	-- "last index of _ in _"
	variable tList
	put [false, true, true, false, true] into tList
	variable tNoBefore

	put the last index of true in tList into tNoBefore
	test "index before (+ve, 0)" when the index of true before 0 in tList is tNoBefore

	put the first index of true in tList into tNoBefore
	test "first index before (+ve, 0)" when the first index of true before 0 in tList is tNoBefore

	put the last index of true in tList into tNoBefore
	test "last index before (+ve, 0)" when the last index of true before 0 in tList is tNoBefore
end handler

----------------------------------------------------------------
-- Finding subsequence offsets
----------------------------------------------------------------

public handler TestOffset()
	variable tList
	put ["x", 1, true, [], []] into tList

	test "offset" when the offset of [1, true] in tList is 2
	test "offset (missing)" when the offset of [true, 1] in tList is 0
	test "offset (missing, overlap start)" when the offset of [false, "x"] in tList is 0
	test "offset (missing, overlap end)" when the offset of [[], [], false] in tList is 0

	test "first offset" when the first offset of [[]] in tList is 4
	test "last offset" when the last offset of [[]] in tList is 5

	test "offset (empty)" when the offset of [] in tList is 0
end handler

----------------------------------------------------------------

handler TestOffsetAfter_InvalidPositive()
	return the offset of [true] after 2 in [true]
end handler
handler TestOffsetAfter_InvalidNegative()
	return the offset of [true] after -3 in [true]
end handler
handler TestFirstOffsetAfter_InvalidPositive()
	return the first offset of [true] after 2 in [true]
end handler
handler TestFirstOffsetAfter_InvalidNegative()
	return the first offset of [true] after -3 in [true]
end handler
handler TestLastOffsetAfter_InvalidPositive()
	return the last offset of [true] after 2 in [true]
end handler
handler TestLastOffsetAfter_InvalidNegative()
	return the last offset of [true] after -3 in [true]
end handler
public handler TestOffsetAfter()
	variable tList
	put [true, false, true, true, false] into tList

	test "offset after (+ve)" when the offset of [true,false] after 1 in tList is 4
	test "offset after (-ve)" when the offset of [true,false] after -5 in tList is 4
	test "offset after (-ve, limit)" when the offset of [true,false] after -6 in tList is 1
	test "offset after (+ve, missing)" when the offset of [false,true] after 2 in tList is 0
	test "offset after (-ve, missing)" when the offset of [false,true] after -4 in tList is 0

	MCUnitTestHandlerThrows(TestOffsetAfter_InvalidPositive, "offset after (+ve, invalid)")
	MCUnitTestHandlerThrows(TestOffsetAfter_InvalidNegative, "offset after (-ve, invalid)")
end handler
public handler TestFirstOffsetAfter()
	variable tList
	put [true, false, true, true, false] into tList

	test "first offset after (+ve)" when the first offset of [true,false] after 1 in tList is 4
	test "first offset after (-ve)" when the first offset of [true,false] after -5 in tList is 4
	test "first offset after (-ve, limit)" when the first offset of [true,false] after -6 in tList is 1
	test "first offset after (+ve, missing)" when the first offset of [false,true] after 2 in tList is 0
	test "first offset after (-ve, missing)" when the first offset of [false,true] after -4 in tList is 0

	MCUnitTestHandlerThrows(TestFirstOffsetAfter_InvalidPositive, "first offset after (+ve, invalid)")
	MCUnitTestHandlerThrows(TestFirstOffsetAfter_InvalidNegative, "first offset after (-ve, invalid)")
end handler
public handler TestLastOffsetAfter()
	variable tList
	put [true, false, true, true, false] into tList

	test "last offset after (+ve)" when the last offset of [true] after 1 in tList is 4
	test "last offset after (-ve)" when the last offset of [true] after -5 in tList is 4
	test "last offset after (-ve, limit)" when the last offset of [true] after -6 in tList is 4
	test "last offset after (+ve, missing)" when the last offset of [true] after 4 in tList is 0
	test "last offset after (-ve, missing)" when the last offset of [true] after -2 in tList is 0

	MCUnitTestHandlerThrows(TestLastOffsetAfter_InvalidPositive, "last offset after (+ve, invalid)")
	MCUnitTestHandlerThrows(TestLastOffsetAfter_InvalidNegative, "last offset after (-ve, invalid)")
end handler
public handler TestOffsetAfterZero()
	-- "offset of _ after 0 in _" should be equivalent to "offset of _ in _"
	variable tList
	put [true, false, true, true, false] into tList
	variable tNoAfter

	put the offset of [true,false] in tList into tNoAfter
	test "offset after (+ve, 0)" when the offset of [true,false] after 0 in tList is tNoAfter

	put the first offset of [true,false] in tList into tNoAfter
	test "first offset after (+ve, 0)" when the first offset of [true,false] after 0 in tList is tNoAfter

	put the last offset of [true,false] in tList into tNoAfter
	test "last offset after (+ve, 0)" when the last offset of [true,false] after 0 in tList is tNoAfter
end handler

----------------------------------------------------------------

handler TestOffsetBefore_InvalidPositive()
	return the offset of [true] before 3 in [true]
end handler
handler TestOffsetBefore_InvalidNegative()
	return the offset of [true] before -2 in [true]
end handler
handler TestFirstOffsetBefore_InvalidPositive()
	return the first offset of [true] before 3 in [true]
end handler
handler TestFirstOffsetBefore_InvalidNegative()
	return the first offset of [true] before -2 in [true]
end handler
handler TestLastOffsetBefore_InvalidPositive()
	return the last offset of [true] before 3 in [true]
end handler
handler TestLastOffsetBefore_InvalidNegative()
	return the last offset of [true] before -2 in [true]
end handler
public handler TestOffsetBefore()
	variable tList
	put [true, false, true, true, false] into tList

	test "offset before (+ve)" when the offset of [true,false] before 4 in tList is 1
	test "offset before (-ve)" when the offset of [true,false] before -2 in tList is 1
	test "offset before (+ve, limit)" when the offset of [true,false] before 6 in tList is 4
	test "offset before (+ve, missing)" when the offset of [false,true] before 2 in tList is 0
	test "offset before (-ve, missing)" when the offset of [false,true] before -4 in tList is 0

	MCUnitTestHandlerThrows(TestOffsetBefore_InvalidPositive, "offset before (+ve, invalid)")
	MCUnitTestHandlerThrows(TestOffsetBefore_InvalidNegative, "offset before (-ve, invalid)")
end handler
public handler TestFirstOffsetBefore()
	variable tList
	put [true, false, true, true, false] into tList

	test "first offset before (+ve)" when the first offset of [true,false] before 5 in tList is 1
	test "first offset before (-ve)" when the first offset of [true,false] before -1 in tList is 1
	test "first offset before (+ve, limit)" when the first offset of [true,false] before 6 in tList is 1
	test "first offset before (+ve, missing)" when the first offset of [false,true] before 2 in tList is 0
	test "first offset before (-ve, missing)" when the first offset of [false,true] before -4 in tList is 0

	MCUnitTestHandlerThrows(TestFirstOffsetBefore_InvalidPositive, "first offset before (+ve, invalid)")
	MCUnitTestHandlerThrows(TestFirstOffsetBefore_InvalidNegative, "first offset before (-ve, invalid)")
end handler
public handler TestLastOffsetBefore()
	variable tList
	put [true, false, true, true, false] into tList

	test "last offset before (+ve)" when the last offset of [true,false] before 4 in tList is 1
	test "last offset before (-ve)" when the last offset of [true,false] before -2 in tList is 1
	test "last offset before (+ve, limit)" when the last offset of [true,false] before 6 in tList is 4
	test "last offset before (+ve, missing)" when the last offset of [false,true] before 2 in tList is 0
	test "last offset before (-ve, missing)" when the last offset of [false,true] before -4 in tList is 0

	MCUnitTestHandlerThrows(TestLastOffsetBefore_InvalidPositive, "last offset before (+ve, invalid)")
	MCUnitTestHandlerThrows(TestLastOffsetBefore_InvalidNegative, "last offset before (-ve, invalid)")
end handler
public handler TestOffsetBeforeZero()
	-- "offset of _ before 0 in _" should be equivalent to "last offset of _ in _"
	variable tList
	put [true, false, true, true, false] into tList
	variable tNoBefore

	put the last offset of [true,false] in tList into tNoBefore
	test "offset before (+ve, 0)" when the offset of [true,false] before 0 in tList is tNoBefore

	put the first offset of [true,false] in tList into tNoBefore
	test "first offset before (+ve, 0)" when the first offset of [true,false] before 0 in tList is tNoBefore

	put the last offset of [true,false] in tList into tNoBefore
	test "last offset before (+ve, 0)" when the last offset of [true,false] before 0 in tList is tNoBefore
end handler

----------------------------------------------------------------

public handler TestConcat()
	test "concat" when ["x"] & ["y"] is ["x", "y"]
end handler

----------------------------------------------------------------

public handler TestReverse()
	variable tReversed

	put [1, 2, 3] into tReversed
	reverse tReversed
	test "reverse in-place (odd)" when tReversed is [3, 2, 1]
	reverse tReversed
	test "rereverse in-place (odd)" when tReversed is [1, 2, 3]


	put [1, 2, 3, 4] into tReversed
	reverse tReversed
	test "reverse in-place (even)" when tReversed is [4, 3, 2, 1]
	reverse tReversed
	test "rereverse in-place (even)" when tReversed is [1, 2, 3, 4]

	put [] into tReversed
	reverse tReversed
	test "reverse in-place (empty)" when tReversed is empty
end handler

end module