public void PersistentVectorTests()
{
IPersistentVector <int> target = new PersistentVector <int>();
target = target.Cons(1);
target = target.Cons(5);
target = target.Cons(10);
target = target.Cons(20);
Assert.AreEqual(4, target.Count);
Assert.AreEqual(4, target.Length());
Assert.AreEqual(20, target.Peek());
Assert.AreEqual(5, target.Nth(1));
Assert.AreEqual(5, target.ValAt(1));
Assert.AreEqual(5, target.ValAt(1, 666));
Assert.AreEqual(666, target.ValAt(5, 666));
Assert.AreEqual(5, target.EntryAt(1).Value);
Assert.IsTrue(target.ContainsKey(2));
target = target.Pop();
Assert.AreEqual(3, target.Count);
Assert.AreEqual(10, target.Peek());
target = target.AssocN(1, 9);
Assert.AreEqual(3, target.Count);
Assert.AreEqual(9, target.Nth(1));
try
{
target = target.AssocN(15, 8);
Assert.Fail();
}
catch (Exception)
{
//Expected exception
}
IPersistentVector <int> target2 = new PersistentVector <int>(new[] { 3, 56, 55, 8 });
IPersistentVector <int> target3 = new PersistentVector <int>(new[] { 3, 56, 55, 8 });
Assert.AreEqual(target2, target3);
Assert.AreEqual(target2, target3);
Assert.AreEqual(target2.GetHashCode(), target3.GetHashCode());
target = target.Cons(-9);
target = target.SubVec(2, 4);
Assert.AreEqual(2, target.Count);
Assert.AreEqual(10, target.Nth(0));
Assert.AreEqual(-9, target.Nth(1));
target = target.Without(10);
Assert.AreEqual(1, target.Count);
Assert.AreEqual(-9, target.Peek());
target = target.Empty();
Assert.AreEqual(0, target.Count);
}
public void CreateOnISeqReturnsCorrectCount()
{
ISeq r = LongRange.create(2, 5);
PersistentVector v = PersistentVector.create(r);
Expect(v.count(), EqualTo(r.count()));
}
public void EmptyReturnsEmptyCollection()
{
PersistentVector v = PersistentVector.create(1, 2, 3);
IPersistentCollection e = v.empty();
Expect(e.count(), EqualTo(0));
}
public void EqualsWorksFalseOnDifferentValues()
{
MapEntry me = new MapEntry(1, "abc");
PersistentVector v = PersistentVector.create(1, "abcd");
Expect(me.Equals(v), False);
}
public void PopOnSizeOneReturnsEmpty()
{
PersistentVector v = PersistentVector.create(1);
IPersistentStack s = v.pop();
Expect(s.count(), EqualTo(0));
}
public void AssocNOutOfRangeHighThrowsException()
{
ISeq r = LongRange.create(2, 5);
PersistentVector v1 = PersistentVector.create(r);
v1.assocN(4, 10);
}
public void HashCodeSameAsPersistentVector()
{
MapEntry me = new MapEntry(1, "abc");
PersistentVector v = PersistentVector.create(1, "abc");
Expect(me.GetHashCode()).To.Equal(v.GetHashCode());
}
public void EqualsWorksOnPersistentVector()
{
MapEntry me = new MapEntry(1, "abc");
PersistentVector v = PersistentVector.create(1, "abc");
Expect(me.Equals(v));
}
public void AssocNOutOfRangeLowThrowsException()
{
Range r = new Range(2, 5);
PersistentVector v1 = PersistentVector.create(r);
v1.assocN(-4, 10);
}
public void HashCodeFalseOnDifferentValues()
{
MapEntry me = new MapEntry(1, "abc");
PersistentVector v = PersistentVector.create(1, "abcd");
Expect(me.GetHashCode()).To.Not.Equal(v.GetHashCode());
}
public static IPersistentVector toAngleAxis(Quaternion q)
{
float ang;
Vector3 axis;
q.ToAngleAxis(out ang, out axis);
return(PersistentVector.create(ang, axis));
}
public void PopOnSmallReturnsOneLess()
{
ISeq r = LongRange.create(2, 20);
PersistentVector v = PersistentVector.create(r);
IPersistentStack s = v.pop();
Expect(v.count()).To.Equal(r.count());
Expect(s.count()).To.Equal(v.count() - 1);
}
public void TryToGetNonExistendValueViaEntryAt()
{
IPersistentVector <int> target = new PersistentVector <int>();
target = target.Cons(1);
target = target.Cons(2);
target.EntryAt(25);
}
public void TryToGetNonExistentValueForPrimitiveTypeViaValAt()
{
IPersistentVector <int> target = new PersistentVector <int>();
target = target.Cons(1);
target = target.Cons(2);
target.ValAt(25);
}
public void CreateOnISeqHasItems()
{
ISeq r = LongRange.create(2, 5);
PersistentVector v = PersistentVector.create(r);
Expect(v.nth(0), EqualTo(2));
Expect(v.nth(1), EqualTo(3));
Expect(v.nth(2), EqualTo(4));
}
public void StoringNullInAVector()
{
IPersistentVector <string> target = new PersistentVector <string>();
target = target.Cons(null);
Assert.IsNull(target.ValAt(0));
Assert.IsNull(target.Nth(0));
}
public void CreateOnMultipleItemsWorks()
{
PersistentVector v = PersistentVector.create(2, 3, 4);
Expect(v.count()).To.Equal(3);
Expect(v.nth(0)).To.Equal(2);
Expect(v.nth(1)).To.Equal(3);
Expect(v.nth(2)).To.Equal(4);
}
public void CreateOnISeqHasItems()
{
ISeq r = LongRange.create(2, 5);
PersistentVector v = PersistentVector.create(r);
Expect((long)v.nth(0)).To.Equal(2);
Expect((long)v.nth(1)).To.Equal(3);
Expect((long)v.nth(2)).To.Equal(4);
}
public void CreateOnMultipleItemsWorks()
{
PersistentVector v = PersistentVector.create(2, 3, 4);
Expect(v.count(), EqualTo(3));
Expect(v.nth(0), EqualTo(2));
Expect(v.nth(1), EqualTo(3));
Expect(v.nth(2), EqualTo(4));
}
public void AssocNAddsAtEndForEmpty()
{
PersistentVector v1 = PersistentVector.create();
IPersistentVector v2 = v1.assocN(0, "abc");
Expect(v1.count(), EqualTo(0));
Expect(v2.count(), EqualTo(1));
Expect(v2.nth(0), EqualTo("abc"));
}
public void CreateOnISeqHasItems()
{
Range r = new Range(2, 5);
PersistentVector v = PersistentVector.create((ISeq)r);
Expect(v.nth(0), EqualTo(2));
Expect(v.nth(1), EqualTo(3));
Expect(v.nth(2), EqualTo(4));
}
public void PopOnSmallReturnsOneLess()
{
Range r = new Range(2, 20);
PersistentVector v = PersistentVector.create((ISeq)r);
IPersistentStack s = v.pop();
Expect(v.count(), EqualTo(r.count()));
Expect(s.count(), EqualTo(v.count() - 1));
}
public void Setup()
{
IPersistentMap meta = new DummyMeta();
PersistentTreeSet m = PersistentTreeSet.create(RT.seq(PersistentVector.create("a", "b")));
_objWithNullMeta = (IObj)m;
_obj = _objWithNullMeta.withMeta(meta);
_expectedType = typeof(PersistentTreeSet);
}
public void Setup()
{
IPersistentMap meta = new DummyMeta();
PersistentVector v = PersistentVector.create(2, 3, 4);
_testNoChange = false;
_objWithNullMeta = (IObj)v;
_obj = _objWithNullMeta.withMeta(meta);
_expectedType = typeof(PersistentVector);
}
public void CreateOnISeqWithManyItemsWorks()
{
// Want to bust out of the first tail, so need to insert more than 32 elements.
Range r = new Range(2, 1000);
PersistentVector v = PersistentVector.create((ISeq)r);
Expect(v.count(), EqualTo(r.count()));
for (int i = 0; i < v.count(); ++i)
{
Expect(v.nth(i), EqualTo(i + 2));
}
}
public void ConsOnNon2IPVFails()
{
Dictionary <int, string> d = new Dictionary <int, string>();
d[1] = "a";
d[2] = "b";
IPersistentMap m = PersistentArrayMap.create(d);
IPersistentVector v = PersistentVector.create(2, "c", 3, "d");
IPersistentMap c = m.cons(v);
}
public void EmptyCopiesMeta()
{
IPersistentMap meta = new DummyMeta();
PersistentVector v1 = PersistentVector.create(1, 2, 3);
IPersistentCollection e1 = v1.empty();
PersistentVector v2 = (PersistentVector)v1.withMeta(meta);
IPersistentCollection e2 = v2.empty();
Expect(((IObj)e1).meta()).To.Be.Null();
Expect(Object.ReferenceEquals(((IObj)e2).meta(), meta));
}
public void EmptyCopiesMeta()
{
IPersistentMap meta = new DummyMeta();
PersistentVector v1 = PersistentVector.create(1, 2, 3);
IPersistentCollection e1 = v1.empty();
PersistentVector v2 = (PersistentVector)v1.withMeta(meta);
IPersistentCollection e2 = v2.empty();
Expect(((IObj)e1).meta(), Null);
Expect(((IObj)e2).meta(), SameAs(meta));
}
public void CreateOnISeqWithManyItemsWorks()
{
// Want to bust out of the first tail, so need to insert more than 32 elements.
ISeq r = LongRange.create(2, 1000);
PersistentVector v = PersistentVector.create(r);
Expect(v.count()).To.Equal(r.count());
for (int i = 0; i < v.count(); ++i)
{
Expect((long)v.nth(i)).To.Equal(i + 2L);
}
}
public void Setup()
{
_mocks = new MockRepository();
IPersistentMap meta = _mocks.StrictMock <IPersistentMap>();
_mocks.ReplayAll();
PersistentVector v = PersistentVector.create(2, 3, 4);
_objWithNullMeta = (IObj)v;
_obj = _objWithNullMeta.withMeta(meta);
_expectedType = typeof(PersistentVector);
}
