private int ReplicateBidirectional(ITestableReplicationProviderInside providerA,
ITestableReplicationProviderInside providerB, Type clazz)
{
int replicatedObjects = 0;
IReplicationSession replicationSession = Replication.Begin(providerA, providerB,
null, _fixtures.reflector);
IObjectSet changedInA = clazz == null?providerA.ObjectsChangedSinceLastReplication
() : providerA.ObjectsChangedSinceLastReplication(clazz);
foreach (object obj in changedInA)
{
replicatedObjects++;
replicationSession.Replicate(obj);
}
IObjectSet changedInB = clazz == null?providerB.ObjectsChangedSinceLastReplication
() : providerB.ObjectsChangedSinceLastReplication(clazz);
foreach (object obj in changedInB)
{
replicatedObjects++;
replicationSession.Replicate(obj);
}
replicationSession.Commit();
return(replicatedObjects);
}
private void DeleteObject(ITestableReplicationProviderInside container, string name
)
{
Replicated obj = Find(container, name);
container.Delete(obj);
}
private void StoreNewPilotIn(ITestableReplicationProviderInside provider)
{
Pilot pilot = new Pilot();
provider.StoreNew(pilot);
provider.Commit();
provider.WaitForPreviousCommits();
}
private Replicated Find(ITestableReplicationProviderInside container, string name
)
{
IEnumerator storedObjects = container.GetStoredObjects(typeof(Replicated)).GetEnumerator
();
int resultCount = 0;
Replicated result = null;
while (storedObjects.MoveNext())
{
Replicated replicated = (Replicated)storedObjects.Current;
if (replicated == null)
{
throw new Exception();
}
if (name.Equals(replicated.GetName()))
{
result = replicated;
resultCount++;
}
}
if (resultCount > 1)
{
Fail("At most one object with name " + name + " was expected.");
}
return(result);
}
public virtual void Test()
{
ITestableReplicationProviderInside providerA = A().Provider();
ITestableReplicationProviderInside providerB = B().Provider();
providerA.StoreNew(new Pilot());
providerA.Commit();
IReplicationSession replication = Replication.Begin(providerA, providerB, null, _fixtures
.reflector);
TimeStamps initialTimeStampsB = AssertTimeStampsForFirstReplication(providerB);
IObjectSet modifiedObjects = providerA.ObjectsChangedSinceLastReplication();
while (modifiedObjects.HasNext())
{
replication.Replicate(modifiedObjects.Next());
}
replication.Commit();
Pilot replicatedPilot = (Pilot)providerB.GetStoredObjects(typeof(Pilot)).Next();
long version = providerB.ObjectVersion(replicatedPilot);
Assert.AreEqual(initialTimeStampsB.Commit(), version);
replication = Replication.Begin(providerA, providerB, null, _fixtures.reflector);
TimeStamps timestampsBAfterReplication = AssertTimeStampsForSecondReplication(initialTimeStampsB
, providerB);
replication.Commit();
Pilot pilotStoredAfterReplication = new Pilot();
providerB.StoreNew(pilotStoredAfterReplication);
providerB.Commit();
providerB.WaitForPreviousCommits();
version = providerB.ObjectVersion(pilotStoredAfterReplication);
Assert.IsGreater(timestampsBAfterReplication.Commit(), version);
}
protected virtual void Delete(ITestableReplicationProviderInside provider)
{
ArrayList toDelete = new ArrayList();
IEnumerator rr = provider.GetStoredObjects(typeof(R0)).GetEnumerator();
while (rr.MoveNext())
{
object o = rr.Current;
IReflectClass claxx = ReplicationReflector().ForObject(o);
SetFieldsToNull(o, claxx);
toDelete.Add(o);
}
object commitObject = null;
for (IEnumerator iterator = toDelete.GetEnumerator(); iterator.MoveNext();)
{
object o = iterator.Current;
//System.out.println("o = " + o);
provider.Delete(o);
commitObject = o;
}
if (commitObject != null)
{
provider.Commit();
}
else
{
provider.Commit();
}
}
private void ReplicateR4(ITestableReplicationProviderInside peerA, ITestableReplicationProviderInside
peerB)
{
int replicatedObjectsCount = ReplicateAll(peerA, peerB, true);
Assert.AreEqual(Linkers, replicatedObjectsCount);
}
public _IBlock4_60(PerformanceTestCase _enclosing, ITestableReplicationProviderInside
from, ITestableReplicationProviderInside to)
{
this._enclosing = _enclosing;
this.from = from;
this.to = to;
}
public object QueryItem(ITestableReplicationProviderInside provider, Type type)
{
IObjectSet result = provider.GetStoredObjects(type);
Assert.AreEqual(1, result.Count);
return(result.Next());
}
protected virtual void Delete(ITestableReplicationProviderInside provider)
{
ArrayList toDelete = new ArrayList();
IEnumerator rr = provider.GetStoredObjects(typeof(R0)).GetEnumerator();
while (rr.MoveNext())
{
object o = rr.Current;
IReflectClass claxx = ReplicationReflector().ForObject(o);
SetFieldsToNull(o, claxx);
toDelete.Add(o);
}
object commitObject = null;
for (IEnumerator iterator = toDelete.GetEnumerator(); iterator.MoveNext(); )
{
object o = iterator.Current;
//System.out.println("o = " + o);
provider.Delete(o);
commitObject = o;
}
if (commitObject != null)
{
provider.Commit();
}
else
{
provider.Commit();
}
}
private void StoreNewAndCommit(ITestableReplicationProviderInside provider, CollectionHolder
h1)
{
provider.StoreNew(h1);
provider.Activate(h1);
provider.Commit();
}
private void CheckEmpty(ITestableReplicationProviderInside provider)
{
if (provider.GetStoredObjects(typeof(Replicated)).GetEnumerator().MoveNext())
{
throw new Exception(provider.GetName() + " is not empty");
}
}
private void StoreToProviderA()
{
ITestableReplicationProviderInside providerA = A().Provider();
providerA.StoreNew(CreateItem());
providerA.Commit();
}
public virtual void Store(ITestableReplicationProviderInside provider)
{
provider.StoreNew(r4);
provider.StoreNew(r3);
provider.StoreNew(r2);
provider.StoreNew(r1);
provider.StoreNew(r0);
}
private void Replicate(ITestableReplicationProviderInside from, ITestableReplicationProviderInside
to)
{
long duration = StopWatch.Time(new _IBlock4_60(this, from, to));
Sharpen.Runtime.Out.WriteLine("Time to replicate " + TotalObjectCount + " objects: "
+ duration + "ms");
}
public override void EnsureContent(ITestableReplicationProviderInside provider)
{
Container replicated = (Container)QueryItem(provider, typeof(Container));
Container expected = (Container)CreateItem();
Assert.AreNotSame(expected, replicated);
Assert.AreEqual(expected._name, replicated._name);
Iterator4Assert.AreEqual(expected._items.GetEnumerator(), replicated._items.GetEnumerator());
}
private void StoreNewPilotIn(ITestableReplicationProviderInside provider)
{
Pilot pilot = new Pilot();
provider.StoreNew(pilot);
provider.Commit();
provider.WaitForPreviousCommits();
}
private void EnsureContent(Container container, ITestableReplicationProviderInside
provider)
{
IObjectSet result = provider.GetStoredObjects(container.GetType());
Assert.AreEqual(1, result.Count);
Container c = Next(result);
Assert.AreEqual(template.GetValue(), c.GetValue());
}
public virtual void Store(ITestableReplicationProviderInside provider)
{
provider.StoreNew(r4);
provider.StoreNew(r3);
provider.StoreNew(r2);
provider.StoreNew(r1);
provider.StoreNew(r0);
}
internal virtual void StoreToProviderA()
{
ITestableReplicationProviderInside provider = A().Provider();
provider.StoreNew(template);
provider.Commit();
EnsureContent(template, provider);
}
protected virtual void ReplicateAll(ITestableReplicationProviderInside from, ITestableReplicationProviderInside
to, IReplicationEventListener listener)
{
IReplicationSession replication = Replication.Begin(from, to, listener, _fixtures
.reflector);
ReplicateAll(replication, from.ObjectsChangedSinceLastReplication().GetEnumerator
());
}
public override void EnsureContent(ITestableReplicationProviderInside provider)
{
Container replicated = (Container)QueryItem(provider, typeof(Container));
Container expected = (Container)CreateItem();
Assert.AreNotSame(expected, replicated);
Assert.AreEqual(expected._name, replicated._name);
Iterator4Assert.AreEqual(expected._items.GetEnumerator(), replicated._items.GetEnumerator());
}
private void EnsureCount(ITestableReplicationProviderInside provider, int linkers
)
{
EnsureCount(provider, typeof(R0), linkers * 5);
EnsureCount(provider, typeof(R1), linkers * 4);
EnsureCount(provider, typeof(R2), linkers * 3);
EnsureCount(provider, typeof(R3), linkers * 2);
EnsureCount(provider, typeof(R4), linkers * 1);
}
private void EnsureCount(ITestableReplicationProviderInside provider, int linkers
)
{
EnsureCount(provider, typeof(R0), linkers * 5);
EnsureCount(provider, typeof(R1), linkers * 4);
EnsureCount(provider, typeof(R2), linkers * 3);
EnsureCount(provider, typeof(R3), linkers * 2);
EnsureCount(provider, typeof(R4), linkers * 1);
}
private TimeStamps AssertTimeStampsForFirstReplication(ITestableReplicationProviderInside
provider)
{
TimeStamps timeStamps = provider.TimeStamps();
Assert.IsNotNull(timeStamps);
Assert.AreEqual(0, timeStamps.From());
Assert.IsGreater(0, timeStamps.To());
Assert.AreEqual(timeStamps.To() + 1, timeStamps.Commit());
return timeStamps;
}
protected virtual void ReplicateClass(ITestableReplicationProviderInside providerA
, ITestableReplicationProviderInside providerB, Type clazz)
{
IReplicationSession replication = Replication.Begin(providerA, providerB, null, _fixtures
.reflector);
IEnumerator allObjects = providerA.ObjectsChangedSinceLastReplication(clazz).GetEnumerator
();
ReplicateAll(replication, allObjects);
}
private void EnsureContent(Container container, ITestableReplicationProviderInside
provider)
{
IObjectSet result = provider.GetStoredObjects(container.GetType());
Assert.AreEqual(1, result.Count);
Container c = Next(result);
Assert.AreEqual(template.GetValue(), c.GetValue());
}
private TimeStamps AssertTimeStampsForSecondReplication(TimeStamps initialTimeStamps
, ITestableReplicationProviderInside provider)
{
TimeStamps timeStamps = provider.TimeStamps();
Assert.IsNotNull(timeStamps);
Assert.AreEqual(initialTimeStamps.Commit(), timeStamps.From());
Assert.IsGreater(timeStamps.From(), timeStamps.To());
Assert.AreEqual(timeStamps.To() + 1, timeStamps.Commit());
return timeStamps;
}
private void Store(IDrsProviderFixture fixture, SimpleListHolder listHolder)
{
ITestableReplicationProviderInside provider = fixture.Provider();
provider.StoreNew(listHolder);
provider.StoreNew(GetItem(listHolder, "foo"));
provider.StoreNew(GetItem(listHolder, "foobar"));
provider.Commit();
EnsureContents(fixture, listHolder);
}
private void PrintProviderContent(ITestableReplicationProviderInside provider)
{
IObjectSet storedObjects = provider.GetStoredObjects(typeof(Replicated));
Sharpen.Runtime.Out.WriteLine("PROVIDER: " + provider);
while (storedObjects.HasNext())
{
Sharpen.Runtime.Out.WriteLine(storedObjects.Next());
}
}
private void ModifyPilotIn(ITestableReplicationProviderInside provider, string newName
)
{
Pilot pilot;
pilot = (Pilot)provider.GetStoredObjects(typeof(Pilot)).Next();
pilot.SetName(newName);
provider.Update(pilot);
provider.Commit();
provider.WaitForPreviousCommits();
}
private void ModifyPilotIn(ITestableReplicationProviderInside provider, string newName
)
{
Pilot pilot;
pilot = (Pilot)provider.GetStoredObjects(typeof(Pilot)).Next();
pilot.SetName(newName);
provider.Update(pilot);
provider.Commit();
provider.WaitForPreviousCommits();
}
private TimeStamps AssertTimeStampsForFirstReplication(ITestableReplicationProviderInside
provider)
{
TimeStamps timeStamps = provider.TimeStamps();
Assert.IsNotNull(timeStamps);
Assert.AreEqual(0, timeStamps.From());
Assert.IsGreater(0, timeStamps.To());
Assert.AreEqual(timeStamps.To() + 1, timeStamps.Commit());
return(timeStamps);
}
private TimeStamps AssertTimeStampsForSecondReplication(TimeStamps initialTimeStamps
, ITestableReplicationProviderInside provider)
{
TimeStamps timeStamps = provider.TimeStamps();
Assert.IsNotNull(timeStamps);
Assert.AreEqual(initialTimeStamps.Commit(), timeStamps.From());
Assert.IsGreater(timeStamps.From(), timeStamps.To());
Assert.AreEqual(timeStamps.To() + 1, timeStamps.Commit());
return(timeStamps);
}
private void PrintProviderContent(ITestableReplicationProviderInside provider)
{
IObjectSet storedObjects = provider.GetStoredObjects(typeof(Replicated));
Sharpen.Runtime.Out.WriteLine("PROVIDER: " + provider);
while (storedObjects.HasNext())
{
object @object = storedObjects.Next();
Sharpen.Runtime.Out.WriteLine("-> " + @object + " - c:" + CreationTime(provider,
@object) + " v:" + Version(provider, @object));
}
}
private void EnsureCount(ITestableReplicationProviderInside provider, Type clazz,
int count)
{
IEnumerator instances = provider.GetStoredObjects(clazz).GetEnumerator();
int i = count;
while (instances.MoveNext())
{
object o = instances.Current;
i--;
}
Assert.AreEqual(0, i);
}
protected virtual void ReplicateAll(ITestableReplicationProviderInside providerFrom
, ITestableReplicationProviderInside providerTo)
{
IReplicationSession replication = Replication.Begin(providerFrom, providerTo, _fixtures
.reflector);
IObjectSet changedSet = providerFrom.ObjectsChangedSinceLastReplication();
if (changedSet.Count == 0)
{
throw new Exception("Can't find any objects to replicate");
}
ReplicateAll(replication, changedSet.GetEnumerator());
}
private void ChangeObject(ITestableReplicationProviderInside container, string name
, string newName)
{
Replicated obj = Find(container, name);
if (obj == null)
{
return;
}
obj.SetName(newName);
container.Update(obj);
Out("CHANGED: " + container + ": " + name + " => " + newName + " - " + obj);
}
private void ModifyR4(ITestableReplicationProviderInside provider)
{
object commitObject = null;
IEnumerator it = provider.GetStoredObjects(typeof(R4)).GetEnumerator();
while (it.MoveNext())
{
R4 r4 = (R4)it.Current;
r4.SetName(r4.GetName() + "_");
provider.Update(r4);
commitObject = r4;
}
provider.Commit();
}
protected override void ReplicateClass(ITestableReplicationProviderInside providerA
, ITestableReplicationProviderInside providerB, Type clazz)
{
IReplicationSession replication = Replication.Begin(providerA, providerB, _fixtures
.reflector);
IEnumerator allObjects = providerA.ObjectsChangedSinceLastReplication(clazz).GetEnumerator
();
while (allObjects.MoveNext())
{
object obj = allObjects.Current;
//System.out.println("obj = " + obj);
replication.Replicate(obj);
}
replication.Commit();
}
private void EnsureContent(NewPilot newPilot, ITestableReplicationProviderInside
provider)
{
IObjectSet objectSet = provider.GetStoredObjects(typeof(NewPilot));
Assert.AreEqual(1, objectSet.Count);
IEnumerator iterator = objectSet.GetEnumerator();
Assert.IsTrue(iterator.MoveNext());
NewPilot p = (NewPilot)iterator.Current;
Assert.AreEqual(newPilot.GetName(), p.GetName());
Assert.AreEqual(newPilot.GetPoints(), p.GetPoints());
for (int j = 0; j < newPilot.GetArr().Length; j++)
{
Assert.AreEqual(newPilot.GetArr()[j], p.GetArr()[j]);
}
}
private void CompareR4(ITestableReplicationProviderInside a, ITestableReplicationProviderInside
b, bool isSameExpected)
{
IEnumerator it = a.GetStoredObjects(typeof(R4)).GetEnumerator();
while (it.MoveNext())
{
string name = ((R4)it.Current).GetName();
IEnumerator it2 = b.GetStoredObjects(typeof(R4)).GetEnumerator();
bool found = false;
while (it2.MoveNext())
{
string name2 = ((R4)it2.Current).GetName();
if (name.Equals(name2))
{
found = true;
}
}
Assert.IsTrue(found == isSameExpected);
}
}
private int ReplicateBidirectional(ITestableReplicationProviderInside providerA,
ITestableReplicationProviderInside providerB, Type clazz)
{
int replicatedObjects = 0;
IReplicationSession replicationSession = Replication.Begin(providerA, providerB,
null, _fixtures.reflector);
IObjectSet changedInA = clazz == null ? providerA.ObjectsChangedSinceLastReplication
() : providerA.ObjectsChangedSinceLastReplication(clazz);
foreach (object obj in changedInA)
{
replicatedObjects++;
replicationSession.Replicate(obj);
}
IObjectSet changedInB = clazz == null ? providerB.ObjectsChangedSinceLastReplication
() : providerB.ObjectsChangedSinceLastReplication(clazz);
foreach (object obj in changedInB)
{
replicatedObjects++;
replicationSession.Replicate(obj);
}
replicationSession.Commit();
return replicatedObjects;
}
public virtual void Open()
{
_provider = new TransientReplicationProvider(new byte[] { 65 }, _name);
}
private void ReplicateR4(ITestableReplicationProviderInside peerA, ITestableReplicationProviderInside
peerB)
{
int replicatedObjectsCount = ReplicateAll(peerA, peerB, true);
Assert.AreEqual(Linkers, replicatedObjectsCount);
}
private void ReplicateNoneModified(ITestableReplicationProviderInside peerA, ITestableReplicationProviderInside
peerB)
{
Assert.IsTrue(Replicate(peerA, peerB) == 0);
}
private int ReplicateAll(ITestableReplicationProviderInside peerA, ITestableReplicationProviderInside
peerB, bool modifiedOnly)
{
IReplicationSession replication = Replication.Begin(peerA, peerB, null, _fixtures
.reflector);
IEnumerator it = modifiedOnly ? peerA.ObjectsChangedSinceLastReplication(typeof(R0
)).GetEnumerator() : peerA.GetStoredObjects(typeof(R0)).GetEnumerator();
int replicated = 0;
while (it.MoveNext())
{
R0 r0 = (R0)it.Current;
replication.Replicate(r0);
replicated++;
}
replication.Commit();
EnsureCount(peerA, Linkers);
EnsureCount(peerB, Linkers);
return replicated;
}
private int Replicate(ITestableReplicationProviderInside peerA, ITestableReplicationProviderInside
peerB)
{
return ReplicateAll(peerA, peerB, true);
}
private void ModifyR4(ITestableReplicationProviderInside provider)
{
object commitObject = null;
IEnumerator it = provider.GetStoredObjects(typeof(R4)).GetEnumerator();
while (it.MoveNext())
{
R4 r4 = (R4)it.Current;
r4.SetName(r4.GetName() + "_");
provider.Update(r4);
commitObject = r4;
}
provider.Commit();
}
private void Init(ITestableReplicationProviderInside peerA)
{
R0Linker lCircles = new R0Linker();
lCircles.SetNames("circles");
lCircles.LinkCircles();
lCircles.Store(peerA);
R0Linker lList = new R0Linker();
lList.SetNames("list");
lList.LinkList();
lList.Store(peerA);
R0Linker lThis = new R0Linker();
lThis.SetNames("this");
lThis.LinkThis();
lThis.Store(peerA);
R0Linker lBack = new R0Linker();
lBack.SetNames("back");
lBack.LinkBack();
lBack.Store(peerA);
peerA.Commit();
}
private void StoreNewAndCommit(ITestableReplicationProviderInside provider, CollectionHolder
h1)
{
provider.StoreNew(h1);
provider.Activate(h1);
provider.Commit();
}
private void Replicate(ITestableReplicationProviderInside from, ITestableReplicationProviderInside
to)
{
long duration = StopWatch.Time(new _IBlock4_60(this, from, to));
Sharpen.Runtime.Out.WriteLine("Time to replicate " + TotalObjectCount + " objects: "
+ duration + "ms");
}
public _IBlock4_60(PerformanceTestCase _enclosing, ITestableReplicationProviderInside
from, ITestableReplicationProviderInside to)
{
this._enclosing = _enclosing;
this.from = from;
this.to = to;
}
public virtual void Close()
{
_provider.Destroy();
_db.Close();
_provider = null;
}
public virtual void Open()
{
_db = Db4oFactory.OpenFile(CloneConfiguration(), testFile.GetPath()).Ext();
_provider = Db4oProviderFactory.NewInstance(_db, _name);
}
private void EnsureNotExist(ITestableReplicationProviderInside provider, Type type
)
{
Assert.IsTrue(!provider.GetStoredObjects(type).GetEnumerator().MoveNext());
}
private void ReplicateAllToB(ITestableReplicationProviderInside peerA, ITestableReplicationProviderInside
peerB)
{
Assert.AreEqual(Linkers * 5, ReplicateAll(peerA, peerB, false));
}
private void EnsureR4Same(ITestableReplicationProviderInside peerA, ITestableReplicationProviderInside
peerB)
{
CompareR4(peerB, peerA, true);
CompareR4(peerA, peerB, true);
}
private void EnsureCount(ITestableReplicationProviderInside provider, Type clazz,
int count)
{
IEnumerator instances = provider.GetStoredObjects(clazz).GetEnumerator();
int i = count;
while (instances.MoveNext())
{
object o = instances.Current;
i--;
}
Assert.AreEqual(0, i);
}
private void EnsureR4Different(ITestableReplicationProviderInside peerA, ITestableReplicationProviderInside
peerB)
{
CompareR4(peerB, peerA, false);
}
