tests/org.eclipse.epsilon.eol.engine.test.acceptance/src/org/eclipse/epsilon/eol/engine/test/acceptance/CollectionsTests.eol

@test
operation testFirst() {
	assertEquals(1, Sequence{1,2,3}.first);
}

@test
operation testIncludesCollection() {
	var seq = Sequence{Set{1,2}};
	assertEquals(seq.includes(Set{1,2}), true);
}

@test
operation testSetsNotEqual() {
	assertNotEquals(Set{Set{1}, 2, Set{3}}, Set{Set{1}, 2, Sequence{3}});
}

@test
operation testSetsEqual() {
	assertEquals(Set{Set{1}, 2, Set{3}}, Set{Set{1}, 2, Set{3}});
}

@test
operation testSequencesNotEqual() {
	assertNotEquals(Sequence{Set{1}, 2, Set{3}}, Sequence{Set{1}, 2, Sequence{3}});
}

@test
operation testSequencesEqual() {
	assertEquals(Sequence{Set{1}, 2, Set{3}}, Sequence{Set{1}, 2, Set{3}});
}

@test
operation testIncludes() {
	assertEquals(Set{Set{2}}.includes(Set{2}), true);
}

@test
operation testExcludes() {
	assertEquals(Set{Set{2}}.excludes(Set{3}), true);
}

@test
operation testExcluding() {
	assertEquals(Sequence{1,2,3}.excluding(2), Sequence{1,3});
}

@test
operation testExcludingAll() {
	assertEquals(Sequence{1,2,3}.excludingAll(Sequence{1,2}), Sequence{3});
}

@test
operation testIncluding() {
	assertEquals(Sequence{1,2,3}.including(4), Sequence{1,2,3,4});
}

@test
operation testIncludingAll() {
	assertEquals(Sequence{1,2,3}.includingAll(Sequence{4,5}), Sequence{1,2,3,4,5});
}

@test
operation testLast() {
	assertEquals(Sequence{1,2,3}.last(),3);
}

@test
operation testSequenceEquals() {
	assertEquals(Sequence{1,2}, Sequence{1,2});
}

@test
operation testModifiedSetUniqueness() {
	var s = Set{1,2,3};
	s.add(1);
	assertEquals(s.size(), 3);
}

@test
operation testRemoveDuplicates() {
	var seq = Sequence{1,1,2,3};
	assertEquals(seq.asSet().size(), 3);
}

@test
operation testEolSetFromUnmodifiableSet() {
	var grp1 : Map;
	grp1.put('a','aaa');
	grp1.put('b','bbb');
	grp1.keySet().println(); 
}

@test
operation testSortByOnOrderedSet() {
	
	var a = 1; a.~x = 3;
	var b = 2; b.~x = 2;
	var c = 3; c.~x = 1;
	
	assertEquals(OrderedSet{a,b,c}.sortBy(i|i.~x), Sequence{c, b, a});
}

@test
operation testSortWithDuplicates() {
	assertEquals(Sequence{1,1,2,3}.sortBy(x|x), Sequence{1,1,2,3});
}

@test
operation testSortSquare() {
	assertEquals(Sequence{2, 1, -1}.sortBy(x|x.pow(2)), Sequence{1, -1, 2});
}

@test
operation testDeclaredSetUniqueness() {
	assertEquals(Set{1,1,2,3}.size(), 3);
}

@test
operation testSetIncludesObject() {
	var eClass = EClass.all.random();
	var set : Set;
	set.add(eClass);
	assertEquals(set.includes(eClass), true);
}

@test
operation testSequenceIncludesObject() {
	var eClass = EClass.all.random();
	var seq : Sequence;
	seq.add(eClass);
	assertEquals(seq.includes(eClass), true);
}

@test
operation testSetIncludesPrimitive() {
	var prim = 1;
	var set : Set;
	set.add(prim);
	assertEquals(set.includes(prim), true);
}

@test
operation testSequenceIncludesPrimitive() {
	var prim = 1;
	var seq : Sequence;
	seq.add(prim);
	assertEquals(seq.includes(prim), true);
}

@test
operation testConvertedSetUniqueness() {
	assertEquals(Sequence{1,1,2,3}.asSet().size(), 3);
}

@test
operation testCount() {
	assertEquals(Sequence{1,2,2,3}.count(2), 2);
}

@test
operation testRandom() {
	assertEquals(Sequence{1,1,1}.random(), 1);
}

@test
operation testIncludingSize() {
	assertEquals(Sequence{1,2,3}.including(4).size(), 4);
}

@test
operation testBagEquals() {
	assertNotEquals(Bag{1,1,2}, Bag{1,2,2});
}

@test
operation testReorderedSetEquals() {
	assertEquals(Set{1,2,3}, Set{2,1,3});
}

@test
operation testOrderedSetAt() {
	assertEquals(OrderedSet{1,2,3}.at(1), 2);
}

@test
operation testSequenceAt() {
	assertEquals(Sequence{1,2,3}.at(1), 2);
}

@test
operation testIncludesAll() {
	assertEquals(Sequence{"a", "b"}.includesAll(Sequence{"c"}), false);
}

@test
operation testSequenceRange() {
	assertEquals(Sequence{1..10}.size(), 10);
}

@test
operation testInvalidSequenceRanges() {
	assertError(Sequence{0.1..10});
	assertError(Sequence{"foo".."bar"});
}

@test
operation testReverseSequenceRange() {
	assertEquals(Sequence{10..5}, Sequence {10,9,8,7,6,5});
}

@test
operation testInvert() {
	assertEquals(Sequence{1,2,3}.invert(), Sequence{3,2,1});
}

@test
operation testSelectCorrectTypeSequence() {
	assertEquals(Sequence{1,2,3}.select(x|true).isTypeOf(Sequence), true);	
}

@test
operation testSelectCorrectTypeSet() {
	assertEquals(Set{1,2,3}.select(x|true).isTypeOf(Set), true);
}

@test
operation testCollectCorrectTypeSet() {
	assertEquals(Set{1,2,3}.collect(x|x).isTypeOf(Bag), true);
}

@test
operation testSelectCorrectTypeOrderedSet() {
	assertEquals(OrderedSet{1,2,3}.select(x|true).isTypeOf(OrderedSet), true);
}

@test
operation testCollectCorrectTypeOrderedSet() {
	assertEquals(OrderedSet{1,2,3}.collect(x|x).isTypeOf(Sequence), true);
}

@test
operation testSelectCorrectTypeBag() {
	assertEquals(Bag{1,2,3}.select(x|true).isTypeOf(Bag), true);
}

@test
operation testRemoveByIndexInSequence() {
	var s = Sequence{"a","b","c"};
	s.removeAt(1);
	assertEquals(s, Sequence{"a","c"});
}

@test
operation testRemoveByIndexInOrderedSet() {
	var s = OrderedSet{1,2,3};
	s.removeAt(1);
	assertEquals(OrderedSet{1,3}, s);
}

@test
operation testRemove() {
	var s = Sequence{1,2,3};
	s.remove(1);
	assertEquals(s, Sequence{2,3});
}

@test
operation testConcat() {
	var s = Sequence{1,2,3};
	assertEquals(s.concat(), '123');
}

@test
operation testConcatEmpty() {
	var s = Sequence{};
	assertEquals(s.concat(), '');
}

@test
operation testConcatWithGlue() {
	var s = Sequence{1,2,3};
	assertEquals(s.concat('-'), '1-2-3');
}

@test
operation testClosure() {
	var s = Sequence {Sequence{1, 2}, 3, Sequence{4, 5}};
	var expected = Sequence {
		Sequence {1, 2},
		Sequence {4, 5}
	};
	var flattened = expected.flatten;

	// The result of the body of the closure is traversed as
	// a collection, and its elements are added to the closure:
	// if we want to preserve the original sequences
	assertEquals(expected, s.closure(e : Sequence | Sequence {e}));

	// If we do not do that, the elements in the subsequences
	// will be collected into a "flattened" list
	assertEquals(flattened, s.closure(e : Sequence | e));
}

@test
operation testAggregate() {
	var s = Sequence {1,2,3};

	// Doesn't work, as we need both the key and the value ASTs
	assertError(s.aggregate(e | e * 2));

	// Does work
	var r = s.aggregate(e | e, e * 2);
	assertEquals(3, r.size);
	for (k in r.keySet) {
	  assertEquals(k*2, r.get(k));
	}
}

@test
operation testEmptyMapLiteral() {
	assertEquals(0, Map {}.size());
}

@test
operation testMapLiteralWithOneElement() {
	// not using a variable
	assertEquals(1, Map {"c" = "d"}.size());
	assertEquals("d", Map {"c" = "d"}.get("c"));

	// using a variable
	var m = Map { "a" = "b" };
	assertEquals(1, m.size());
	assertEquals("b", m.get("a"));
}

@test
operation testMapLiteralWithTwoElements() {
	var m = Map { "a" = 1, "b" = 3 };
	assertEquals(2, m.size());
	assertEquals(1, m.get("a"));
	assertEquals(3, m.get("b"));
}

@test
operation testMapLiteralWithNestedEquals() {
    // No ambiguity: keys cannot use logical or relational operators,
    // unless between parenthesis
	var m := Map { "x" = "x" = 3 };
	assertEquals(1, m.size());
	assertEquals(false, m.get("x"));
}

@test
operation testMapLiteralWithEqualsBetweenParens() {
	var m := Map { ("x" = "x") = 3 };
	assertEquals(1, m.size());
	assertEquals(3, m.get(true));
}

@test
operation testMapLiteralWithCollectionKeys() {
	assertEquals(1, Map { Sequence {1..5} = "test" }.size());

	var s := Sequence {1..3};
	var m := Map { s = "me!" };
	assertEquals(1, m.size());
	assertEquals("me!", m.get(s));
}

@test
operation testSequenceSize() {
    assertEquals(0, Sequence {}.size);
}

@test
operation testBagSize() {
    assertEquals(1, Bag {1}.size);
}

@test
operation testMapSize() {
    assertEquals(2, Map {1 = 2, 2 = 3}.size);
}