package GroupTests

@Test
function testGroupBasic()
	let g = CreateGroup()
	assertTrue(g != null)
	assertTrue(g.isEmpty())

	let u = createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg())
	assertTrue(u != null)
	g.add(u)
	g.size().assertEquals(1)

	var count = 0

	for i = 1 to 10
		count += g.add(createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg()))

	g.size().assertEquals(11)
	count.assertEquals(10)

	let u2 = createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg())
	g.add(u2)
	assertTrue(g.get(0) == u)
	g.size().assertEquals(12)
	assertTrue(g.get(g.size()-1) == u2)

	for int i = 0 to g.size()-1
		print(g.get(i).getHandleId())
	print("---")
	print(u2.getHandleId())

	g.clear()
	assertTrue(g.isEmpty())


@Test
function testGroupForLoops()
	let g = CreateGroup()
	assertTrue(g != null)
	assertTrue(not g.hasNext())
	for i = 0 to 10
		g.add(createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg()))

	assertTrue(g.hasNext())

	for u in g
		assertTrue(u != null)

	for _ from g
		skip

	assertTrue(not g.hasNext())


@Test
function testRandom()
	let g = CreateGroup()

	for i = 0 to 10
		g.add(createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg()))

	let ru = g.getRandom()

	assertTrue(ru != null)

	assertTrue(g.has(ru))

	g.remove(ru)

	for i = 1 to 10
		g.remove(g.getRandom())

	assertTrue(g.isEmpty())

@Test
function testHandleId()
	let g = CreateGroup()
	assertTrue(g.getHandleId() != 0)

	for i = 0 to 100
		let g2 = CreateGroup()
		assertTrue(g2.getHandleId() != 0)
		assertTrue(g2.getHandleId() != g.getHandleId())

@Test
function testVararg()
	let g = CreateGroup()
	g.add(createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg()), createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg()), createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg()))
	g.size().assertEquals(3)

	unit array units
	var _count = 0

	for i = 0 to 9
		units[i] = createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg())

	g.clear()

	_count = g.add(units[0], units[1], units[2], units[3])
	_count.assertEquals(4)

	_count += g.add(units[2], units[3], units[4], units[5])
	_count.assertEquals(6)

	g.clear()

	let a = CreateGroup()
	..add(units[0], units[1], units[2], units[3], units[4], units[5])
	let b = CreateGroup()
	..add(units[4], units[5], units[6], units[7], units[8], units[9])

	_count = g.add(a)
	_count.assertEquals(a.size())

	_count = g.add(b)
	_count.assertEquals(4)

	g.clear()
	_count = g.add(a, b)
	_count.assertEquals(10)

	_count = g.remove(units[0], units[1], units[2])
	_count.assertEquals(3)

	_count = g.remove(a, b)
	_count.assertEquals(7)
	assertTrue(g.isEmpty())

@Test
function testGroupForGroups()
	let u = createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg())
	let u2 = createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg())
	let u3 = createUnit(Player(0), 'hfoo', vec2(0, 0), 0 .fromDeg())

	let g = CreateGroup()
	g.add(u, u2)
	g.size().assertEquals(2)

	let g2 = CreateGroup()
	g2.add(g)
	g2.size().assertEquals(g.size())
	g2.has(u).assertTrue()

	g2.add(u3)
	g2.remove(g)
	g2.size().assertEquals(1)
	g2.has(u3).assertTrue()
	g2.has(u2).assertFalse()
	g2.has(u).assertFalse()