public void ListTest()
{
RegData._cnt = 0;
var root = new RegData()
{
_name = @"foo"
};
var lst = new List <RegData>();
lst.Add(root);
// root._name = "bar";
//for (int i = 0; i < 100; i++)
//{
// lst.Add(new RegData() { _name = "foo" });
//}
//lst.Add(new RegData() { _name = "foo" });
lst.Add(root);
using (var mfd = new MapFileDict <int, List <RegData> >())
{
mfd[1] = lst;
var ret = mfd[1];
Assert.IsTrue(ret[0].CompareTo(root) == 0);
}
Assert.IsTrue(RegData._cnt == 3, "count = {0}", RegData._cnt);
}
private void DoIt(
uint nInstances,
int nLoops,
MapMemTypes mapfileType = MapMemTypes.MapMemTypePageFile,
bool fDoDeleteStuff = false,
bool fUseNormDict = false
)
{
Assert.AreEqual(IntPtr.Size, 4, "intptr != 4?");
for (uint iLoop = 0; iLoop < nLoops; iLoop++)
{
uint ulInitialFileSize = 0;
if (fDoDeleteStuff)
{
}
IDictionary <int, DataClass> dict;
using (var mfd = new MapFileDict <int, DataClass>(ulInitialSize: ulInitialFileSize, mapfileType: mapfileType))
{
if (fUseNormDict)//|| true)
{
dict = new Dictionary <int, DataClass>();
}
else
{
dict = mfd;
}
try
{
// Assert.IsTrue(mfd._objSize == 36, "obj size = 36");
for (int i = 00; i < nInstances; i++)
{
var testInstance = DataClass.MakeInstance((ulong)i);
dict[(int)i] = testInstance;
var res = i;
var retrievedInstance = dict[(int)i];
Assert.AreEqual(testInstance, retrievedInstance, "objects not equal Count=" + dict.Count.ToString());
if (fDoDeleteStuff)
{
}
}
for (int i = 00; i < nInstances; i++)
{
var retrievedInstance = dict[i];
var testInstance = DataClass.MakeInstance((ulong)i);
Assert.AreEqual(testInstance, retrievedInstance, "objects not equal Count=" + dict.Count.ToString());
}
//dict.Clear();
mfd.VerifyNoLeaks();
}
catch (Exception ex)
{
mfd.Dispose();
Assert.Fail("exception lp={0} cnt={1} {2}\r\n{3}", iLoop, mfd.Count, mfd._MemMap._stats.ToString(), ex.ToString());
throw;
}
}
}
}
public void RandStuff()
{
uint nInstances = 100000;
using (var dict = new MapFileDict <int, DataClass>())
{
try
{
for (int lp = 0; lp < 1; lp++)
{
for (int i = 0; i < nInstances; i++)
{
var rndInd = _random.Next((int)nInstances);
var rnd = _random.Next(10000) / 10;
dict[rndInd] = new DataClass()
{
int1 = rndInd,
uint2 = (uint)rnd,
str5 = string.Format("foo{0}", new string('1', rnd))
};
dict[rndInd].str5 = "bar";
var x = dict[rndInd];
Assert.AreEqual(rndInd, x.int1, "rnd inst not eq");
}
}
// throw new InvalidOperationException("Test Passed");
}
catch (Exception ex)
{
dict.Dispose();
Assert.Fail("exception lp={0} cnt={1} {2}\r\n{3}", 0, dict.Count, dict._MemMap._stats.ToString(), ex.ToString());
}
dict.VerifyNoLeaks();
}
}
public void DictStuff()
{
uint nInstances = 546200;
nInstances = 100000;
using (var dict = new MapFileDict <int, string>())
{
int i = 0;
try
{
// var randstr = new string('a', 100000);
for (i = 0; i < nInstances; i++)
{
var randstr = new string('a', _random.Next(10000));
var teststr = string.Format("Foo {0}, {1}", i, randstr);
dict[i] = teststr;
var retrieved = dict[i];
Assert.AreEqual(teststr, retrieved, "strs not eq " + i.ToString());
dict[i] = "bar";
}
//throw new InvalidOperationException("Test Passed");
}
catch (Exception ex)
{
dict.Dispose();
Assert.Fail("exception lp={0} cnt={1} {2}\r\n{3}", i, dict.Count, dict._MemMap._stats.ToString(), ex.ToString());
throw;
}
dict.VerifyNoLeaks();
}
}
public void TestNullStr()
{
using (var mfd = new MapFileDict <int, DataClass>())
{
var t = new DataClass()
{
str5 = null, int1 = 1
};
mfd[1] = (t);
var ret = mfd[1];
Assert.AreEqual(t, ret);
mfd.VerifyNoLeaks();
}
}
public void ValueCollectionException()
{
using (var mfd = new MapFileDict <int, DataClass>())
{
var t = DataClass.MakeInstance(9);
mfd[1] = (t);
var ret = mfd[1];
Assert.AreEqual(t, ret);
var vc = mfd.Values;
foreach (var x in vc)
{
mfd[2] = t; // change collection in middle of iterationl
}
}
}
public void TreeTest()
{
var root = new RegData()
{
_name = regroot
};
root.Fillit();
// Assert.IsTrue(RegData._cnt > 350, "count = {0}", RegData._cnt);
using (var mfd = new MapFileDict <int, RegData>())
{
mfd[1] = root;
var ret = mfd[1];
Assert.IsTrue(ret.CompareTo(root) == 0, "not equal!");
}
// Assert.IsTrue(false, "Count = {0}", RegData._cnt);
}
public void ValueCollection()
{
using (var mfd = new MapFileDict <int, DataClass>())
{
var t = DataClass.MakeInstance(9);
mfd[1] = (t);
mfd[2] = t;
var ret = mfd[1];
Assert.AreEqual(t, ret);
var vc = mfd.Values;
int ncnt = 0;
foreach (var x in vc)
{
ncnt++;
Assert.AreEqual(t, x);
}
Assert.AreEqual(ncnt, 2, "didn't get right count");
mfd.VerifyNoLeaks();
}
}
public override async Task DoInitializeAsync()
{
// Sample demonstrates putting lots of data in a dictionary.
// The dictionary can be either a normal System.Collectsions.Generic.Dictionary<K,V>
// or a MapFileDict<K,V>, because they both implement IDictionary<K,V>
bool fUseMapDict = false;
if (!fUseMapDict)
{
dict = new Dictionary <int, DataClass>();
}
else
{
var mapfileType = MapMemTypes.MapMemTypePageFile; // store data in system page file
mapfileType = MapMemTypes.MapMemTypeFileName; // store data in temp file on disk
mfd = new MapFileDict <int, DataClass>(ulInitialSize: 0, mapfileType: mapfileType);
// mfd._MemMap.ChangeViewSize(65536 * 2); // can change default memory map view size
dict = mfd;
}
_logger.LogMessage("Using " + dict.GetType().Name);
}
public void TreeTestLazy()
{
var root = new RegDataLazy()
{
_name = regroot
};
root.Fillit();
// Assert.IsTrue(RegData._cnt > 350, "count = {0}", RegData._cnt);
var zz = (RegDataLazy)Activator.CreateInstance(root.GetType());
using (var mfd = new MapFileDict <int, RegDataLazy>())
{
mfd[1] = root;
var ret = mfd[1];
Assert.IsTrue(ret.CompareTo(root) == 0, "not equal! #items= {0}", RegDataLazy._cnt);
}
Assert.IsTrue(false, "Count = {0}", RegDataLazy._cnt);
}
