public void Run(TestConfig config)
{
int i;
Record r = null;
int count = config.Count;
var res = new TestIndexNumericResult();
config.Result = res;
var start = DateTime.Now;
IDatabase db = config.GetDatabase();
Tests.Assert(null == db.Root);
var idx = db.CreateIndex <float, Record>(IndexType.NonUnique);
db.Root = idx;
long val = 1999;
for (i = 0; i < count; i++)
{
float idxVal = Clamp(val);
r = new Record(idxVal);
idx.Put(idxVal, r);
if (i % 100 == 0)
{
db.Commit();
}
val = (3141592621L * val + 2718281829L) % 1000000007L;
}
idx.Put(min, new Record(min));
idx.Put(max, new Record(max));
Tests.Assert(idx.Count == count + 2);
db.Commit();
res.InsertTime = DateTime.Now - start;
start = System.DateTime.Now;
Record[] recs = idx[min, mid];
i = 0;
foreach (var r2 in recs)
{
Tests.Assert(r2.nval >= min && r2.nval <= mid);
i++;
}
recs = idx[mid, max];
i = 0;
foreach (var r2 in recs)
{
Tests.Assert(r2.nval >= mid && r2.nval <= max);
i++;
}
float prev = min;
i = 0;
var e1 = idx.GetEnumerator();
while (e1.MoveNext())
{
r = e1.Current;
Tests.Assert(r.nval >= prev);
prev = r.nval;
i++;
}
Tests.VerifyEnumeratorDone(e1);
prev = min;
i = 0;
foreach (var r2 in idx)
{
Tests.Assert(r2.nval >= prev);
prev = r2.nval;
i++;
}
prev = min;
i = 0;
foreach (var r2 in idx.Range(min, max, IterationOrder.AscentOrder))
{
Tests.Assert(r2.nval >= prev);
prev = r2.nval;
i++;
}
prev = max;
i = 0;
foreach (var r2 in idx.Range(min, max, IterationOrder.DescentOrder))
{
Tests.Assert(prev >= r2.nval);
prev = r2.nval;
i++;
}
prev = max;
i = 0;
foreach (var r2 in idx.Reverse())
{
Tests.Assert(prev >= r2.nval);
prev = r2.nval;
i++;
}
long usedBeforeDelete = db.UsedSize;
recs = idx[min, max];
i = 0;
foreach (var r2 in recs)
{
Tests.Assert(!r2.IsDeleted());
idx.Remove(r2.nval, r2);
r2.Deallocate();
i++;
}
Tests.Assert(idx.Count == 0);
db.Commit();
long usedAfterDelete = db.UsedSize;
db.Gc();
db.Commit();
long usedAfterGc = db.UsedSize;
db.Close();
}
public void Run(TestConfig config)
{
int i;
Record r = null;
int count = config.Count;
var res = new TestIndexNumericResult();
config.Result = res;
var start = DateTime.Now;
IDatabase db = config.GetDatabase();
Tests.Assert(null == db.Root);
var idx = db.CreateIndex <ushort, Record>(IndexType.NonUnique);
db.Root = idx;
int countOf1999 = 0;
i = 0;
foreach (var val in Tests.KeySeq(count))
{
ushort idxVal = Clamp(val);
if (val == 1999)
{
countOf1999++;
}
r = new Record(idxVal);
idx.Put(idxVal, r);
i++;
if (i % 100 == 0)
{
db.Commit();
}
}
idx.Put(min, new Record(min));
idx.Put(max, new Record(max));
Tests.Assert(idx.Count == count + 2);
db.Commit();
res.InsertTime = DateTime.Now - start;
Tests.Assert(idx.Count == count + 2);
start = System.DateTime.Now;
Record[] recs = idx[min, mid];
foreach (var r2 in recs)
{
Tests.Assert(r2.lval >= min && r2.lval <= mid);
}
recs = idx[mid, max];
foreach (var r2 in recs)
{
Tests.Assert(r2.lval >= mid && r2.lval <= max);
}
recs = idx[min, max];
Tests.Assert(recs.Length == count + 2);
recs = idx[min, min];
Tests.Assert(recs.Length >= 1);
recs = idx[max, max];
Tests.Assert(1 == recs.Length);
// TODO: figure out why returns no values
recs = idx[1999, 1999];
Tests.Assert(1 == recs.Length);
ushort prev = min;
var e1 = idx.GetEnumerator();
while (e1.MoveNext())
{
r = e1.Current;
Tests.Assert(r.nval >= prev);
prev = r.nval;
}
Tests.VerifyEnumeratorDone(e1);
prev = min;
foreach (var r2 in idx)
{
Tests.Assert(r2.nval >= prev);
prev = r2.nval;
}
prev = min;
foreach (var r2 in idx.Range(min, max, IterationOrder.AscentOrder))
{
Tests.Assert(r2.nval >= prev);
prev = r2.nval;
}
prev = max;
foreach (var r2 in idx.Range(min, max, IterationOrder.DescentOrder))
{
Tests.Assert(prev >= r2.nval);
prev = r2.nval;
}
prev = max;
foreach (var r2 in idx.Reverse())
{
Tests.Assert(prev >= r2.nval);
prev = r2.nval;
}
long usedBeforeDelete = db.UsedSize;
recs = idx[min, max];
foreach (var r2 in recs)
{
Tests.Assert(!r2.IsDeleted());
idx.Remove(r2.nval, r2);
r2.Deallocate();
}
Tests.Assert(idx.Count == 0);
db.Commit();
long usedAfterDelete = db.UsedSize;
db.Gc();
db.Commit();
long usedAfterGc = db.UsedSize;
db.Close();
}
public void Run(TestConfig config)
{
int i;
Record r = null;
int count = config.Count;
var res = new TestIndexNumericResult();
config.Result = res;
var start = DateTime.Now;
IDatabase db = config.GetDatabase();
Tests.Assert(null == db.Root);
var idx = db.CreateIndex<byte, Record>(IndexType.NonUnique);
db.Root = idx;
long val = 1999;
for (i = 0; i < count; i++)
{
byte idxVal = Clamp(val);
r = new Record(idxVal);
idx.Put(idxVal, r);
if (i % 100 == 0)
db.Commit();
val = (3141592621L * val + 2718281829L) % 1000000007L;
}
idx.Put(min, new Record(min));
idx.Put(max, new Record(max));
Tests.Assert(idx.Count == count + 2);
db.Commit();
res.InsertTime = DateTime.Now - start;
Tests.Assert(idx.Count == count + 2);
start = System.DateTime.Now;
Record[] recs = idx[min, mid];
foreach (var r2 in recs)
{
Tests.Assert(r2.lval >= min && r2.lval <= mid);
}
recs = idx[mid, max];
foreach (var r2 in recs)
{
Tests.Assert(r2.lval >= mid && r2.lval <= max);
}
byte prev = min;
var e1 = idx.GetEnumerator();
while (e1.MoveNext())
{
r = e1.Current;
Tests.Assert(r.nval >= prev);
prev = r.nval;
}
Tests.VerifyEnumeratorDone(e1);
prev = min;
foreach (var r2 in idx)
{
Tests.Assert(r2.nval >= prev);
prev = r2.nval;
}
prev = min;
foreach (var r2 in idx.Range(min, max, IterationOrder.AscentOrder))
{
Tests.Assert(r2.nval >= prev);
prev = r2.nval;
}
prev = max;
foreach (var r2 in idx.Range(min, max, IterationOrder.DescentOrder))
{
Tests.Assert(prev >= r2.nval);
prev = r2.nval;
}
prev = max;
foreach (var r2 in idx.Reverse())
{
Tests.Assert(prev >= r2.nval);
prev = r2.nval;
}
long usedBeforeDelete = db.UsedSize;
recs = idx[min, max];
foreach (var r2 in recs)
{
Tests.Assert(!r2.IsDeleted());
idx.Remove(r2.nval, r2);
r2.Deallocate();
}
Tests.Assert(idx.Count == 0);
db.Commit();
long usedAfterDelete = db.UsedSize;
db.Gc();
db.Commit();
long usedAfterGc = db.UsedSize;
db.Close();
}
public void Run(TestConfig config)
{
int i;
Record r = null;
int count = config.Count;
var res = new TestIndexNumericResult();
config.Result = res;
var start = DateTime.Now;
IDatabase db = config.GetDatabase();
Tests.Assert(null == db.Root);
var idx = db.CreateIndex<short, Record>(IndexType.NonUnique);
db.Root = idx;
int countOf1999 = 0;
i = 0;
foreach (long val in Tests.KeySeq(count))
{
short idxVal = Clamp(val);
if (idxVal == 1999)
countOf1999++;
Tests.Assert(idxVal != max);
r = new Record(idxVal);
idx.Put(idxVal, r);
i++;
if (i % 100 == 0)
db.Commit();
}
idx.Put(min, new Record(min));
idx.Put(max, new Record(max));
Tests.Assert(idx.Count == count + 2);
db.Commit();
res.InsertTime = DateTime.Now - start;
Tests.Assert(idx.Count == count + 2);
start = System.DateTime.Now;
Record[] recs = idx[min, mid];
foreach (var r2 in recs)
{
Tests.Assert(r2.lval >= min && r2.lval <= mid);
}
recs = idx[mid, max];
foreach (var r2 in recs)
{
Tests.Assert(r2.lval >= mid && r2.lval <= max);
}
recs = idx[min, max];
Tests.Assert(recs.Length == count + 2);
recs = idx[min, min];
Tests.Assert(1 == recs.Length);
recs = idx[max, max];
Tests.Assert(1 == recs.Length);
recs = idx[1999, 1999];
Tests.Assert(countOf1999 == recs.Length);
recs = idx[min + 1, min + 1];
Tests.Assert(0 == recs.Length);
short prev = min;
var e1 = idx.GetEnumerator();
while (e1.MoveNext())
{
r = e1.Current;
Tests.Assert(r.nval >= prev);
prev = r.nval;
}
Tests.VerifyEnumeratorDone(e1);
prev = min;
foreach (var r2 in idx)
{
Tests.Assert(r2.nval >= prev);
prev = r2.nval;
}
prev = min;
foreach (var r2 in idx.Range(min, max, IterationOrder.AscentOrder))
{
Tests.Assert(r2.nval >= prev);
prev = r2.nval;
}
prev = max;
foreach (var r2 in idx.Range(min, max, IterationOrder.DescentOrder))
{
Tests.Assert(prev >= r2.nval);
prev = r2.nval;
}
prev = max;
foreach (var r2 in idx.Reverse())
{
Tests.Assert(prev >= r2.nval);
prev = r2.nval;
}
long usedBeforeDelete = db.UsedSize;
recs = idx[min, max];
foreach (var r2 in recs)
{
Tests.Assert(!r2.IsDeleted());
idx.Remove(r2.nval, r2);
r2.Deallocate();
}
Tests.Assert(idx.Count == 0);
db.Commit();
long usedAfterDelete = db.UsedSize;
db.Gc();
db.Commit();
long usedAfterGc = db.UsedSize;
db.Close();
}
public void Run(TestConfig config)
{
int i;
Record r = null;
int count = config.Count;
var res = new TestIndexNumericResult();
config.Result = res;
var start = DateTime.Now;
IDatabase db = config.GetDatabase();
Tests.Assert(null == db.Root);
var idx = db.CreateIndex <Record, Record>(IndexType.NonUnique);
db.Root = idx;
long val = 1999;
for (i = 0; i < count; i++)
{
r = new Record(val);
r.MakePersistent(db);
idx.Put(r, r);
if (i % 100 == 0)
{
db.Commit();
}
val = (3141592621L * val + 2718281829L) % 1000000007L;
}
Tests.Assert(idx.Count == count);
db.Commit();
res.InsertTime = DateTime.Now - start;
Tests.Assert(idx.Count == count);
Record[] recs = idx.ToArray();
Array.Sort(recs, (r1, r2) => { return(r1.Oid - r2.Oid); });
Tests.Assert(recs.Length == count);
Record min = recs[0];
Record max = recs[recs.Length - 1];
Record mid = recs[recs.Length / 2];
start = System.DateTime.Now;
recs = idx[min, mid];
i = 0;
foreach (var r2 in recs)
{
Tests.Assert(r2.Oid >= min.Oid && r2.Oid <= mid.Oid);
i++;
}
recs = idx[mid, max];
i = 0;
foreach (var r2 in recs)
{
Tests.Assert(r2.Oid >= mid.Oid && r2.Oid <= max.Oid);
i++;
}
long prev = min.Oid;
i = 0;
var e1 = idx.GetEnumerator();
while (e1.MoveNext())
{
r = e1.Current;
Tests.Assert(r.Oid >= prev);
prev = r.Oid;
i++;
}
Tests.VerifyEnumeratorDone(e1);
prev = min.Oid;
i = 0;
foreach (var r2 in idx)
{
Tests.Assert(r2.Oid >= prev);
prev = r2.Oid;
i++;
}
prev = min.Oid;
i = 0;
foreach (var r2 in idx.Range(min, max, IterationOrder.AscentOrder))
{
Tests.Assert(r2.Oid >= prev);
prev = r2.Oid;
i++;
}
prev = max.Oid;
i = 0;
foreach (var r2 in idx.Range(min, max, IterationOrder.DescentOrder))
{
Tests.Assert(prev >= r2.Oid);
prev = r2.Oid;
i++;
}
prev = max.Oid;
i = 0;
foreach (var r2 in idx.Reverse())
{
Tests.Assert(prev >= r2.Oid);
prev = r2.Oid;
i++;
}
long usedBeforeDelete = db.UsedSize;
recs = idx[min, max];
i = 0;
foreach (var r2 in recs)
{
Tests.Assert(!r2.IsDeleted());
idx.Remove(r2, r2);
r2.Deallocate();
i++;
}
Tests.Assert(idx.Count == 0);
db.Commit();
long usedAfterDelete = db.UsedSize;
db.Gc();
db.Commit();
long usedAfterGc = db.UsedSize;
db.Close();
}
public void Run(TestConfig config)
{
int i;
int count = config.Count;
var res = new TestIndexNumericResult();
config.Result = res;
var start = DateTime.Now;
IDatabase db = config.GetDatabase();
Tests.Assert(null == db.Root);
var set = db.CreateSet<RecordFull>();
db.Root = set;
long val = 1999;
var recs = new List<RecordFull>();
var rand = new Random();
for (i = 0; i < count; i++)
{
var r = new RecordFull(val);
Tests.Assert(!set.Contains(r));
set.Add(r);
set.Add(r);
if (recs.Count < 10 && rand.Next(0, 20) == 4)
recs.Add(r);
Tests.Assert(set.Contains(r));
if (i % 100 == 0)
db.Commit();
val = (3141592621L * val + 2718281829L) % 1000000007L;
}
Tests.Assert(set.Count == count);
db.Commit();
Tests.Assert(set.Count == count);
Tests.Assert(set.IsReadOnly == false);
Tests.Assert(set.ContainsAll(recs));
var rOne = new RecordFull(val);
Tests.Assert(!set.Contains(rOne));
Tests.Assert(!set.ContainsAll(new RecordFull[] { rOne }));
Tests.Assert(set.AddAll(new RecordFull[] { rOne }));
Tests.Assert(!set.AddAll(recs));
Tests.Assert(set.Count == count + 1);
Tests.Assert(set.Remove(rOne));
Tests.Assert(!set.Remove(rOne));
Tests.Assert(set.RemoveAll(recs));
Tests.Assert(!set.RemoveAll(recs));
Tests.Assert(set.Count == count - recs.Count);
Tests.Assert(set.AddAll(recs));
Tests.Assert(set.Count == count);
db.Commit();
res.InsertTime = DateTime.Now - start;
IEnumerator e = set.GetEnumerator();
Tests.Assert(e != null);
start = System.DateTime.Now;
Tests.Assert(!set.Equals(null));
Tests.Assert(set.Equals(set));
var set2 = db.CreateSet<RecordFull>();
Tests.Assert(!set.Equals(set2));
foreach (var r2 in set)
{
Tests.Assert(set.Contains(r2));
set2.Add(r2);
}
Tests.Assert(set.Equals(set2));
RecordFull[] recsArr = set.ToArray();
Tests.Assert(recsArr.Length == count);
set.Clear();
Tests.Assert(set.Count == 0);
db.Commit();
Tests.Assert(set.Count == 0);
set.Invalidate();
set.Load();
set.AddAll(recs);
Tests.Assert(set.Count == recs.Count);
db.Commit();
Tests.Assert(set.Count == recs.Count);
Tests.Assert(set.GetHashCode() > 0);
db.Gc();
// tests for PersistentString
var ps = new PersistentString();
Tests.Assert(ps.Get() == "");
ps = new PersistentString("Hello");
var s = ps.ToString();
Tests.Assert(s == "Hello");
ps.Append("2");
Tests.Assert("Hello2" == ps.Get());
ps.Set("Lala");
Tests.Assert("Lala" == ps.Get());
string s2 = ps;
Tests.Assert("Lala" == s2);
PersistentString ps2 = "Lulu";
Tests.Assert(ps2.Get() == "Lulu");
db.Root = ps;
set.Deallocate();
db.Gc();
db.Commit();
db.Close();
}
public void Run(TestConfig config)
{
int i;
Record r = null;
int count = config.Count;
var res = new TestIndexNumericResult();
config.Result = res;
var start = DateTime.Now;
IDatabase db = config.GetDatabase();
Tests.Assert(null == db.Root);
var idx = db.CreateIndex<Record, Record>(IndexType.NonUnique);
db.Root = idx;
long val = 1999;
for (i = 0; i < count; i++)
{
r = new Record(val);
r.MakePersistent(db);
idx.Put(r, r);
if (i % 100 == 0)
db.Commit();
val = (3141592621L * val + 2718281829L) % 1000000007L;
}
Tests.Assert(idx.Count == count);
db.Commit();
res.InsertTime = DateTime.Now - start;
Tests.Assert(idx.Count == count);
Record[] recs = idx.ToArray();
Array.Sort(recs, (r1, r2) => { return r1.Oid - r2.Oid; });
Tests.Assert(recs.Length == count);
Record min = recs[0];
Record max = recs[recs.Length - 1];
Record mid = recs[recs.Length / 2];
start = System.DateTime.Now;
recs = idx[min, mid];
i = 0;
foreach (var r2 in recs)
{
Tests.Assert(r2.Oid >= min.Oid && r2.Oid <= mid.Oid);
i++;
}
recs = idx[mid, max];
i = 0;
foreach (var r2 in recs)
{
Tests.Assert(r2.Oid >= mid.Oid && r2.Oid <= max.Oid);
i++;
}
long prev = min.Oid;
i = 0;
var e1 = idx.GetEnumerator();
while (e1.MoveNext())
{
r = e1.Current;
Tests.Assert(r.Oid >= prev);
prev = r.Oid;
i++;
}
Tests.VerifyEnumeratorDone(e1);
prev = min.Oid;
i = 0;
foreach (var r2 in idx)
{
Tests.Assert(r2.Oid >= prev);
prev = r2.Oid;
i++;
}
prev = min.Oid;
i = 0;
foreach (var r2 in idx.Range(min, max, IterationOrder.AscentOrder))
{
Tests.Assert(r2.Oid >= prev);
prev = r2.Oid;
i++;
}
prev = max.Oid;
i = 0;
foreach (var r2 in idx.Range(min, max, IterationOrder.DescentOrder))
{
Tests.Assert(prev >= r2.Oid);
prev = r2.Oid;
i++;
}
prev = max.Oid;
i = 0;
foreach (var r2 in idx.Reverse())
{
Tests.Assert(prev >= r2.Oid);
prev = r2.Oid;
i++;
}
long usedBeforeDelete = db.UsedSize;
recs = idx[min, max];
i = 0;
foreach (var r2 in recs)
{
Tests.Assert(!r2.IsDeleted());
idx.Remove(r2, r2);
r2.Deallocate();
i++;
}
Tests.Assert(idx.Count == 0);
db.Commit();
long usedAfterDelete = db.UsedSize;
db.Gc();
db.Commit();
long usedAfterGc = db.UsedSize;
db.Close();
}
public void Run(TestConfig config)
{
int i;
int count = config.Count;
var res = new TestIndexNumericResult();
config.Result = res;
var start = DateTime.Now;
IDatabase db = config.GetDatabase();
Tests.Assert(null == db.Root);
var set = db.CreateSet <RecordFull>();
db.Root = set;
long val = 1999;
var recs = new List <RecordFull>();
var rand = new Random();
for (i = 0; i < count; i++)
{
var r = new RecordFull(val);
Tests.Assert(!set.Contains(r));
set.Add(r);
set.Add(r);
if (recs.Count < 10 && rand.Next(0, 20) == 4)
{
recs.Add(r);
}
Tests.Assert(set.Contains(r));
if (i % 100 == 0)
{
db.Commit();
}
val = (3141592621L * val + 2718281829L) % 1000000007L;
}
Tests.Assert(set.Count == count);
db.Commit();
Tests.Assert(set.Count == count);
Tests.Assert(set.IsReadOnly == false);
Tests.Assert(set.ContainsAll(recs));
var rOne = new RecordFull(val);
Tests.Assert(!set.Contains(rOne));
Tests.Assert(!set.ContainsAll(new RecordFull[] { rOne }));
Tests.Assert(set.AddAll(new RecordFull[] { rOne }));
Tests.Assert(!set.AddAll(recs));
Tests.Assert(set.Count == count + 1);
Tests.Assert(set.Remove(rOne));
Tests.Assert(!set.Remove(rOne));
Tests.Assert(set.RemoveAll(recs));
Tests.Assert(!set.RemoveAll(recs));
Tests.Assert(set.Count == count - recs.Count);
Tests.Assert(set.AddAll(recs));
Tests.Assert(set.Count == count);
db.Commit();
res.InsertTime = DateTime.Now - start;
IEnumerator e = set.GetEnumerator();
Tests.Assert(e != null);
start = System.DateTime.Now;
Tests.Assert(!set.Equals(null));
Tests.Assert(set.Equals(set));
var set2 = db.CreateSet <RecordFull>();
Tests.Assert(!set.Equals(set2));
foreach (var r2 in set)
{
Tests.Assert(set.Contains(r2));
set2.Add(r2);
}
Tests.Assert(set.Equals(set2));
RecordFull[] recsArr = set.ToArray();
Tests.Assert(recsArr.Length == count);
set.Clear();
Tests.Assert(set.Count == 0);
db.Commit();
Tests.Assert(set.Count == 0);
set.Invalidate();
set.Load();
set.AddAll(recs);
Tests.Assert(set.Count == recs.Count);
db.Commit();
Tests.Assert(set.Count == recs.Count);
Tests.Assert(set.GetHashCode() > 0);
db.Gc();
// tests for PersistentString
var ps = new PersistentString();
Tests.Assert(ps.Get() == "");
ps = new PersistentString("Hello");
var s = ps.ToString();
Tests.Assert(s == "Hello");
ps.Append("2");
Tests.Assert("Hello2" == ps.Get());
ps.Set("Lala");
Tests.Assert("Lala" == ps.Get());
string s2 = ps;
Tests.Assert("Lala" == s2);
PersistentString ps2 = "Lulu";
Tests.Assert(ps2.Get() == "Lulu");
db.Root = ps;
set.Deallocate();
db.Gc();
db.Commit();
db.Close();
}
