package LinkedListTests
import LinkedList

@Test
function testAddRemove()
	let list = new LinkedList<int>()
	list.size().assertEquals(0)

	list..add(1, 2, 3, 4)
	list.size().assertEquals(4)

	let itr = list.staticItr()
	while itr.hasNext()
		itr.next()
		itr.remove()

	list.size().assertEquals(0)

@Test
function testForLoop()
	let list = new LinkedList<int>()

	list..add(1, 2, 3, 4)

	list.updateAll(i -> i + 1)

	var result = 0
	for i in list
		result += i

	result.assertEquals(5 + 4 + 3 + 2)

@Test function testBackIter()
	let list = new LinkedList<int>()
	let list2 = new LinkedList<int>()

	list..add(1, 2, 3, 4)
	list2..add(4, 3, 2, 1)

	let bi = list.backiterator()
	let i = list2.iterator()
	while bi.hasNext() and i.hasNext()
		bi.next().assertEquals(i.next())

@Test function testAddAll()
	let list = new LinkedList<int>()
	let list2 = new LinkedList<int>()

	list..add(1, 2)
	list2..add(3, 4)
	list.addAll(list2)

	list.get(2).assertEquals(3)
	list.get(3).assertEquals(4)

	var result = 0
	for i in list
		result += i
	result.assertEquals(1 + 2 + 3 + 4)

@Test function testSplice()
	let list = new LinkedList<int>()
	let list2 = new LinkedList<int>()

	list.add(1, 2)
	list2.add(3, 4)
	list.splice(list2)

	list.get(2).assertEquals(3)
	list.get(3).assertEquals(4)

	list2.size().assertEquals(0)

	var result = 0
	for i in list
		result += i
	result.assertEquals(1 + 2 + 3 + 4)

@Test function testAddVararg()
	let list = new LinkedList<int>()
	let list2 = new LinkedList<int>()

	list.add(1, 2)
	list2.add(3, 4)
	list.addAll(list2)

	list.get(2).assertEquals(3)
	list.get(3).assertEquals(4)

	var result = 0
	for i in list
		result += i
	result.assertEquals(1 + 2 + 3 + 4)

@Test
function testClosures()
	let list = new LinkedList<int>()
	list..add(1, 2, 3, 4)

	list.updateAll(i -> i * 2)
	list.get(3).assertEquals(4 * 2)

	list.removeIf(i -> i > 4)
	list.size().assertEquals(2)

	let realList = list.map<real>(i -> i * 10.)
	realList.get(1).assertEquals(40.)

@Test
function testGenerics()
	let list = new LinkedList<string>()
	list..add("a", "b", "c")
	list.get(1).assertEquals("b")

	let list2 = new LinkedList<real>()
	list2..add(1.230, 2.563, 1213143.)
	list2.get(0).assertEquals(1.230)
	list2.get(1).assertEquals(2.563)
	list2.get(2).assertEquals(1213143.)


@Test function testSort()
	let list = new LinkedList<int>()
	for i = 0 to 400
		list..add(GetRandomInt(-100, 100) * 2 + 1)
	list.sort()

	let itr = list.iterator()
	int i2 = 0
	while itr.hasNext()
		i2++
		let next = itr.next()
		let lookahead = itr.lookahead()
		if lookahead != 0
			next.assertLessThanOrEqual(lookahead)
	itr.close()
	i2.assertEquals(list.size())

	let bitr = list.backiterator()
	int bi2 = 0
	while bitr.hasNext()
		bitr.next().toString()
		bi2++

	bi2.assertEquals(list.size())

@Test function testAddAt()
	let list = new LinkedList<int>()
	for i = 1 to 6
		list.add(i)
	list.addAt(7, 4)
	string elems = ""
	for elem in list
		elems += elem.toString()
	elems.assertEquals("1234756")

@Test function testRemoveWhen()
	let list = new LinkedList<int>()
	for i = 1 to 6
		list.add(i)
	list.removeIf(i -> i < 3)
	list.size().assertEquals(4)
	list.get(2).assertEquals(5)

@Test function testFilter()
	var list = new LinkedList<int>()
	for i = 1 to 6
		list.add(i)
	list = list.filter(i -> i > 3)
	list.size().assertEquals(3)
	list.get(2).assertEquals(6)

@Test function testFoldl()
	let list = new LinkedList<int>()
	for i = 1 to 6
		list.add(i)
	let result = list.foldl<int>(0, (i, q) -> q + i)
	result.assertEquals(21)

@Test function testToString()
	let list = new LinkedList<int>()
	for i = 1 to 6
		list.add(i)
	let result = list.toString()
	result.assertEquals("[1,2,3,4,5,6]")

@Test function testSortReal()
	let list = new LinkedList<real>()
	for i = 6 downto 1
		list.add(i.toReal())
	list.sort()
	list.get(0).assertEquals(1.)
	list.get(5).assertEquals(6.)

@Test function testAsList()
	asList(1,2,3,4).foldl<int>(0, (i, q) -> q + i)
		.assertEquals(asList(4,3,2,1).foldl<int>(0, (i, q) -> q + i))


@Test function testStringHashCollission()
	let testlist = new LinkedList<string>
	testlist.add("a")
	testlist.add("b")
	testlist.add("c")
	testlist.has("a").assertTrue()
	testlist.has("b").assertTrue()
	testlist.has("c").assertTrue()
	testlist.has("x").assertFalse()
	testlist.has("A").assertFalse()

@Test function testGetters()
	let testlist = new LinkedList<string>
	testlist.add("a")
	testlist.add("c")
	testlist.add("b")
	testlist.getFirst().assertEquals("a")
	testlist.get(1).assertEquals("c")

@Test function testJoin()
	let list = new LinkedList<string>()
		..add("this", "is", "a", "string")

	list.join().assertEquals("thisisastring")
	list.joinBy(" ").assertEquals("this is a string")

	destroy list

@Test function testQueue()
	let list = new LinkedList<string>()
		..enqueue("a")
		..enqueue("b")
		..enqueue("c")

	list.getFirst().assertEquals("a")
	list.dequeue().assertEquals("a")
	list.getFirst().assertEquals("b")
	list.dequeue().assertEquals("b")
	list.getFirst().assertEquals("c")
	list.dequeue().assertEquals("c")

	destroy list

@Test function testQueueWithAdd()
	let list = new LinkedList<string>()
		..add("a")
		..add("b")
		..add("c")

	list.getFirst().assertEquals("a")
	list.dequeue().assertEquals("a")
	list.getFirst().assertEquals("b")
	list.dequeue().assertEquals("b")
	list.getFirst().assertEquals("c")
	list.dequeue().assertEquals("c")

	destroy list

@Test function testStack()
	let list = new LinkedList<string>()
		..push("a")
		..push("b")
		..push("c")

	list.peek().assertEquals("c")
	list.pop().assertEquals("c")
	list.peek().assertEquals("b")
	list.pop().assertEquals("b")
	list.peek().assertEquals("a")
	list.pop().assertEquals("a")

	destroy list

@Test function testAddBeforeBackIter()
	let list = new LinkedList<int>()
	let list2 = new LinkedList<int>()

	list..add(1, 2, 3, 4)
	list2..add(4, 3, 7, 8, 9, 2, 1)


	let bi = list.backiterator()
	while bi.hasNext()
		if bi.next() < 4
			bi.addBefore(9)
			bi.addBefore(8)
			bi.addBefore(7)
			break

	bi.reset()
	let i = list2.iterator()
	while bi.hasNext() and i.hasNext()
		bi.next().assertEquals(i.next())

@Test function testAddBeforeIter()
	let list = new LinkedList<int>()
	let list2 = new LinkedList<int>()

	list..add(1, 2, 3, 4)
	list2..add(4, 3, 7, 8, 9, 2, 1)


	let bi = list.iterator()
	while bi.hasNext()
		if bi.next() > 2
			bi.addBefore(9)
			bi.addBefore(8)
			bi.addBefore(7)
			break

	bi.reset()
	let i = list2.backiterator()
	while bi.hasNext() and i.hasNext()
		bi.next().assertEquals(i.next())