public void Default()
{
// Unit RoleTypes
var concreteClasses = this.GetTestTypes();
foreach (var concreteClass in concreteClasses)
{
var roles = this.GetUnitRoles(concreteClass);
foreach (var role in roles)
{
var sourceAssociation = this.GetSession().Create(concreteClass);
var destinationAssociation = this.GetSession().Create(concreteClass);
// Different
var unitTypeTag = (UnitTypeTags)role.ObjectType.UnitTag;
switch (unitTypeTag)
{
case UnitTypeTags.AllorsString:
sourceAssociation.Strategy.SetUnitRole(role, "0");
destinationAssociation.Strategy.SetUnitRole(role, "1");
break;
case UnitTypeTags.AllorsInteger:
sourceAssociation.Strategy.SetUnitRole(role, 0);
destinationAssociation.Strategy.SetUnitRole(role, 1);
break;
case UnitTypeTags.AllorsLong:
sourceAssociation.Strategy.SetUnitRole(role, 0L);
destinationAssociation.Strategy.SetUnitRole(role, 1L);
break;
case UnitTypeTags.AllorsDecimal:
sourceAssociation.Strategy.SetUnitRole(role, 0m);
destinationAssociation.Strategy.SetUnitRole(role, 1m);
break;
case UnitTypeTags.AllorsDouble:
sourceAssociation.Strategy.SetUnitRole(role, 0d);
destinationAssociation.Strategy.SetUnitRole(role, 1d);
break;
case UnitTypeTags.AllorsBoolean:
sourceAssociation.Strategy.SetUnitRole(role, false);
destinationAssociation.Strategy.SetUnitRole(role, true);
break;
case UnitTypeTags.AllorsDate:
sourceAssociation.Strategy.SetUnitRole(role, DateTime.Now);
destinationAssociation.Strategy.SetUnitRole(role, DateTime.Now.AddDays(1d));
break;
case UnitTypeTags.AllorsDateTime:
sourceAssociation.Strategy.SetUnitRole(role, DateTime.Now);
destinationAssociation.Strategy.SetUnitRole(role, DateTime.Now.AddMilliseconds(1d));
break;
case UnitTypeTags.AllorsUnique:
sourceAssociation.Strategy.SetUnitRole(role, Guid.NewGuid());
destinationAssociation.Strategy.SetUnitRole(role, Guid.NewGuid());
break;
case UnitTypeTags.AllorsBinary:
byte[] sourceBinary = { 0xFF, 0x00 };
byte[] destinationBinary = { 0x00, 0xFF };
sourceAssociation.Strategy.SetUnitRole(role, sourceBinary);
destinationAssociation.Strategy.SetUnitRole(role, destinationBinary);
break;
default:
throw new ArgumentException("Unknown Unit ObjectType: " + unitTypeTag);
}
var differingRoles = Diff.Execute(sourceAssociation, destinationAssociation);
Assert.AreEqual(1, differingRoles.Length);
Assert.AreEqual(role, differingRoles[0]);
sourceAssociation = this.GetSession().Create(concreteClass);
destinationAssociation = this.GetSession().Create(concreteClass);
// Same
switch (unitTypeTag)
{
case UnitTypeTags.AllorsString:
const string Str = "0";
sourceAssociation.Strategy.SetUnitRole(role, Str.Clone());
destinationAssociation.Strategy.SetUnitRole(role, Str.Clone());
break;
case UnitTypeTags.AllorsInteger:
sourceAssociation.Strategy.SetUnitRole(role, 0);
destinationAssociation.Strategy.SetUnitRole(role, 0);
break;
case UnitTypeTags.AllorsLong:
sourceAssociation.Strategy.SetUnitRole(role, 0L);
destinationAssociation.Strategy.SetUnitRole(role, 0L);
break;
case UnitTypeTags.AllorsDecimal:
sourceAssociation.Strategy.SetUnitRole(role, 0m);
destinationAssociation.Strategy.SetUnitRole(role, 0m);
break;
case UnitTypeTags.AllorsDouble:
sourceAssociation.Strategy.SetUnitRole(role, 0d);
destinationAssociation.Strategy.SetUnitRole(role, 0d);
break;
case UnitTypeTags.AllorsBoolean:
sourceAssociation.Strategy.SetUnitRole(role, false);
destinationAssociation.Strategy.SetUnitRole(role, false);
break;
case UnitTypeTags.AllorsDate:
var nowDate = DateTime.Now;
sourceAssociation.Strategy.SetUnitRole(role, nowDate);
destinationAssociation.Strategy.SetUnitRole(role, nowDate);
break;
case UnitTypeTags.AllorsDateTime:
var nowDateTime = DateTime.Now;
sourceAssociation.Strategy.SetUnitRole(role, nowDateTime);
destinationAssociation.Strategy.SetUnitRole(role, nowDateTime);
break;
case UnitTypeTags.AllorsUnique:
var guid = Guid.NewGuid();
sourceAssociation.Strategy.SetUnitRole(role, guid);
destinationAssociation.Strategy.SetUnitRole(role, guid);
break;
case UnitTypeTags.AllorsBinary:
byte[] sourceBinary = { 0xFF, 0x00 };
byte[] destinationBinary = { 0xFF, 0x00 };
sourceAssociation.Strategy.SetUnitRole(role, sourceBinary);
destinationAssociation.Strategy.SetUnitRole(role, destinationBinary);
break;
default:
throw new ArgumentException("Unknown Unit ObjectType: " + unitTypeTag);
}
differingRoles = Diff.Execute(sourceAssociation, destinationAssociation);
Assert.AreEqual(0, differingRoles.Length);
}
}
// Many2One Composite RoleTypes (Same repository)
var relationTypes = this.GetMany2OneRelations(this.GetMetaDomain());
foreach (var relationType in relationTypes)
{
var role = relationType.RoleType;
var associationTypes = relationType.AssociationType.ObjectType.ConcreteClasses;
foreach (var associationType in associationTypes)
{
var roleTypes = relationType.RoleType.ObjectType.ConcreteClasses;
foreach (var roleType in roleTypes)
{
var role1 = this.GetSession().Create(roleType);
var role2 = this.GetSession().Create(roleType);
var sourceAssociation = this.GetSession().Create(associationType);
var destinationAssociation = this.GetSession().Create(associationType);
sourceAssociation.Strategy.SetCompositeRole(relationType.RoleType, role1);
destinationAssociation.Strategy.SetCompositeRole(relationType.RoleType, role2);
var differingRoles = Diff.Execute(sourceAssociation, destinationAssociation);
Assert.AreEqual(1, differingRoles.Length);
Assert.AreEqual(role, differingRoles[0]);
sourceAssociation.Strategy.SetCompositeRole(relationType.RoleType, role1);
destinationAssociation.Strategy.SetCompositeRole(relationType.RoleType, role1);
differingRoles = Diff.Execute(sourceAssociation, destinationAssociation);
Assert.AreEqual(0, differingRoles.Length);
}
}
}
// Many2Many Composite RoleTypes (Same repository)
relationTypes = this.GetMany2ManyRelations(this.GetMetaDomain());
foreach (var relationType in relationTypes)
{
var role = relationType.RoleType;
var associationTypes = relationType.AssociationType.ObjectType.ConcreteClasses;
foreach (var associationType in associationTypes)
{
var roleTypes = relationType.RoleType.ObjectType.ConcreteClasses;
foreach (var roleType in roleTypes)
{
var role1 = this.GetSession().Create(roleType);
var role2 = this.GetSession().Create(roleType);
var role3 = this.GetSession().Create(roleType);
var sourceAssociation = this.GetSession().Create(associationType);
var destinationAssociation = this.GetSession().Create(associationType);
sourceAssociation.Strategy.AddCompositeRole(relationType.RoleType, role1);
sourceAssociation.Strategy.AddCompositeRole(relationType.RoleType, role2);
destinationAssociation.Strategy.AddCompositeRole(relationType.RoleType, role2);
destinationAssociation.Strategy.AddCompositeRole(relationType.RoleType, role3);
var differingRoles = Diff.Execute(sourceAssociation, destinationAssociation);
Assert.AreEqual(1, differingRoles.Length);
Assert.AreEqual(role, differingRoles[0]);
sourceAssociation.Strategy.AddCompositeRole(relationType.RoleType, role3);
destinationAssociation.Strategy.AddCompositeRole(relationType.RoleType, role1);
differingRoles = Diff.Execute(sourceAssociation, destinationAssociation);
Assert.AreEqual(0, differingRoles.Length);
}
}
}
// Many2One Composite RoleTypes (Different repository)
relationTypes = this.GetMany2OneRelations(this.GetMetaDomain());
foreach (var relationType in relationTypes)
{
var role = relationType.RoleType;
var associationTypes = relationType.AssociationType.ObjectType.ConcreteClasses;
foreach (var associationType in associationTypes)
{
var roleTypes = relationType.RoleType.ObjectType.ConcreteClasses;
foreach (var roleType in roleTypes)
{
var role1 = this.GetSession().Create(roleType);
var role2 = this.GetSession().Create(roleType);
var otherRole1 = this.GetSession2().Insert(roleType, role1.Strategy.ObjectId);
var otherRole2 = this.GetSession2().Insert(roleType, role2.Strategy.ObjectId);
var sourceAssociation = this.GetSession().Create(associationType);
var destinationAssociation = this.GetSession2().Insert(associationType, sourceAssociation.Strategy.ObjectId);
sourceAssociation.Strategy.SetCompositeRole(relationType.RoleType, role1);
destinationAssociation.Strategy.SetCompositeRole(relationType.RoleType, otherRole2);
var differingRoles = Diff.Execute(sourceAssociation, destinationAssociation);
Assert.AreEqual(1, differingRoles.Length);
Assert.AreEqual(role, differingRoles[0]);
sourceAssociation.Strategy.SetCompositeRole(relationType.RoleType, role1);
destinationAssociation.Strategy.SetCompositeRole(relationType.RoleType, otherRole1);
differingRoles = Diff.Execute(sourceAssociation, destinationAssociation);
Assert.AreEqual(0, differingRoles.Length);
}
}
}
}
public void SaveAndLoad()
{
int[] stringLengths = { 0, 1, 10 };
foreach (var stringLength in stringLengths)
{
var sessionPairs = new ISession[2][];
sessionPairs[0] = new ISession[2];
sessionPairs[1] = new ISession[2];
// From/To same population type
sessionPairs[0][0] = this.GetSession();
sessionPairs[0][1] = this.GetSession2();
// From Memory Population
sessionPairs[1][0] = this.CreateMemoryPopulation().CreateSession();
sessionPairs[1][1] = this.GetSession2();
// To Memory Population
sessionPairs[1][0] = this.GetSession();
sessionPairs[1][1] = this.CreateMemoryPopulation().CreateSession();
foreach (var sessionPair in sessionPairs)
{
var saveSession = sessionPair[0];
var loadSession = sessionPair[1];
var concreteClasses = this.GetTestTypes();
var objectsByMetaType = new Hashtable();
foreach (var concreteClass in concreteClasses)
{
objectsByMetaType[concreteClass] = new ArrayList();
}
for (var i = 0; i < this.ObjectsPerConcreteClass; i++)
{
foreach (var concreteClass in concreteClasses)
{
((ArrayList)objectsByMetaType[concreteClass]).Add(saveSession.Create(concreteClass));
}
}
foreach (var t in concreteClasses)
{
for (var j = 0; j < this.ObjectsPerConcreteClass; j++)
{
var concreteClass = t;
((ArrayList)objectsByMetaType[concreteClass]).Add(saveSession.Create(concreteClass));
}
}
// Unit Role
foreach (var concreteClass in concreteClasses)
{
IObject[] extent = saveSession.Extent(concreteClass);
foreach (var allorsObject in extent)
{
var roles = concreteClass.UnitRoleTypes;
foreach (var role in roles)
{
var unitTypeTag = (UnitTypeTags)role.ObjectType.UnitTag;
switch (unitTypeTag)
{
case UnitTypeTags.AllorsString:
allorsObject.Strategy.SetUnitRole(role, this.ValueGenerator.GenerateString(stringLength));
break;
case UnitTypeTags.AllorsInteger:
allorsObject.Strategy.SetUnitRole(role, this.ValueGenerator.GenerateInteger());
break;
case UnitTypeTags.AllorsLong:
allorsObject.Strategy.SetUnitRole(role, this.ValueGenerator.GenerateLong());
break;
case UnitTypeTags.AllorsDecimal:
allorsObject.Strategy.SetUnitRole(role, this.ValueGenerator.GenerateDecimal());
break;
case UnitTypeTags.AllorsDouble:
allorsObject.Strategy.SetUnitRole(role, this.ValueGenerator.GenerateDouble());
break;
case UnitTypeTags.AllorsBoolean:
allorsObject.Strategy.SetUnitRole(role, this.ValueGenerator.GenerateBoolean());
break;
case UnitTypeTags.AllorsDate:
allorsObject.Strategy.SetUnitRole(role, this.ValueGenerator.GenerateDate());
break;
case UnitTypeTags.AllorsDateTime:
allorsObject.Strategy.SetUnitRole(role, this.ValueGenerator.GenerateDateTime());
break;
case UnitTypeTags.AllorsUnique:
allorsObject.Strategy.SetUnitRole(role, this.ValueGenerator.GenerateUnique());
break;
case UnitTypeTags.AllorsBinary:
allorsObject.Strategy.SetUnitRole(role, this.ValueGenerator.GenerateBinary(10));
break;
default:
throw new ArgumentException("Unknown Unit ObjectType: " + unitTypeTag);
}
}
}
}
// One2One Composite RoleTypes
var relationTypes = this.GetOne2OneRelations(this.GetMetaDomain());
foreach (var relationType in relationTypes)
{
var roles = new ArrayList();
var roleTypes = relationType.RoleType.ObjectType.ConcreteClasses;
for (var iRoleType = roleTypes.Length - 1; iRoleType >= 0; iRoleType--)
{
var roleType = roleTypes[iRoleType];
var rolesForType = (ArrayList)objectsByMetaType[roleType];
for (var j = rolesForType.Count - 1; j >= 0; j--)
{
roles.Add(rolesForType[j]);
}
}
var associationTypes = relationType.AssociationType.ObjectType.ConcreteClasses;
foreach (var associationType in associationTypes)
{
var associations = (ArrayList)objectsByMetaType[associationType];
foreach (IObject association in associations)
{
IObject role = null;
if (roles.Count != 0)
{
role = (IObject)roles[0];
roles.Remove(0);
}
association.Strategy.SetCompositeRole(relationType.RoleType, role);
}
}
}
// Many2One Composite RoleTypes
relationTypes = this.GetMany2OneRelations(this.GetMetaDomain());
foreach (var relationType in relationTypes)
{
var roles = new ArrayList();
var roleTypes = relationType.RoleType.ObjectType.ConcreteClasses;
for (var iRoleType = roleTypes.Length - 1; iRoleType >= 0; iRoleType--)
{
var roleType = roleTypes[iRoleType];
var rolesForType = (ArrayList)objectsByMetaType[roleType];
var reuseRoleType = false;
for (var j = rolesForType.Count - 1; j >= 0; j--)
{
roles.Add(rolesForType[j]);
if (reuseRoleType)
{
reuseRoleType = false;
roles.Add(rolesForType[j]); // many2one, so role can be reused with other associations
}
else
{
reuseRoleType = true;
}
}
}
var associationTypes = relationType.AssociationType.ObjectType.ConcreteClasses;
foreach (var associationType in associationTypes)
{
var associations = (ArrayList)objectsByMetaType[associationType];
foreach (IObject association in associations)
{
IObject role = null;
if (roles.Count != 0)
{
role = (IObject)roles[0];
roles.Remove(0);
}
association.Strategy.SetCompositeRole(relationType.RoleType, role);
}
}
}
// One2Many Composite RoleTypes
relationTypes = this.GetOne2ManyRelations(this.GetMetaDomain());
foreach (var relationType in relationTypes)
{
var roles = new ArrayList();
var roleTypes = relationType.RoleType.ObjectType.ConcreteClasses;
for (var iRoleType = roleTypes.Length - 1; iRoleType >= 0; iRoleType--)
{
var roleType = roleTypes[iRoleType];
var rolesForType = (ArrayList)objectsByMetaType[roleType];
for (var j = rolesForType.Count - 1; j >= 0; j--)
{
roles.Add(rolesForType[j]);
}
}
// Interleave AssociationTypes
var interleavedAssociations = new ArrayList();
var associationTypes = relationType.AssociationType.ObjectType.ConcreteClasses;
for (var i = 0; i < this.ObjectsPerConcreteClass; i++)
{
foreach (var associationType in associationTypes)
{
var associations = (ArrayList)objectsByMetaType[associationType];
interleavedAssociations.Add(associations[i]);
}
}
var addTwice = false;
foreach (var interleavedAssociation in interleavedAssociations)
{
var association = (IObject)interleavedAssociation;
IObject role = null;
if (roles.Count != 0)
{
role = (IObject)roles[0];
roles.Remove(0);
}
association.Strategy.AddCompositeRole(relationType.RoleType, role);
if (addTwice)
{
addTwice = false;
if (roles.Count != 0)
{
role = (IObject)roles[0];
roles.Remove(0);
}
association.Strategy.AddCompositeRole(relationType.RoleType, role);
}
else
{
addTwice = true;
}
}
}
// Many2Many Composite RoleTypes
relationTypes = this.GetMany2ManyRelations(this.GetMetaDomain());
foreach (var relationType in relationTypes)
{
var roles = new ArrayList();
var roleTypes = relationType.RoleType.ObjectType.ConcreteClasses;
for (var iRoleType = roleTypes.Length - 1; iRoleType >= 0; iRoleType--)
{
var roleType = roleTypes[iRoleType];
var rolesForType = (ArrayList)objectsByMetaType[roleType];
var reuseRoleType = false;
for (var j = rolesForType.Count - 1; j >= 0; j--)
{
roles.Add(rolesForType[j]);
if (reuseRoleType)
{
reuseRoleType = false;
roles.Add(rolesForType[j]); // many2many, so role can be reused with other associations
}
else
{
reuseRoleType = true;
}
}
}
// Interleave AssociationTypes
var interleavedAssociations = new ArrayList();
var associationTypes = relationType.AssociationType.ObjectType.ConcreteClasses;
for (var i = 0; i < this.ObjectsPerConcreteClass; i++)
{
foreach (var associationType in associationTypes)
{
var associations = (ArrayList)objectsByMetaType[associationType];
interleavedAssociations.Add(associations[i]);
}
}
var addTwice = false;
foreach (var interleavedAssociation in interleavedAssociations)
{
var association = (IObject)interleavedAssociation;
IObject role = null;
if (roles.Count != 0)
{
role = (IObject)roles[0];
roles.Remove(0);
}
association.Strategy.AddCompositeRole(relationType.RoleType, role);
if (addTwice)
{
addTwice = false;
if (roles.Count != 0)
{
role = (IObject)roles[0];
roles.Remove(0);
}
association.Strategy.AddCompositeRole(relationType.RoleType, role);
}
else
{
addTwice = true;
}
}
}
saveSession.Commit();
var xml = this.Save(saveSession);
// File.WriteAllText("Population.xml", xml);
AssertSchema(xml);
this.Load(loadSession, xml);
// Use diff
foreach (var concreteClass in concreteClasses)
{
IObject[] saveExtent = saveSession.Extent(concreteClass);
foreach (var saveObject in saveExtent)
{
var loadObject = loadSession.Instantiate(saveObject.Strategy.ObjectId);
Assert.IsFalse(Diff.Execute(saveObject, loadObject).Length > 0);
}
}
loadSession.Commit();
}
}
}
void ProcessTables(Diff.Processor proc)
{
var list = TablesTxt.Text.Split(new string[]{ Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
foreach (var item in list)
{
if (Cancelled()) return;
ExecPrint("Table " + item + " being processed...");
ExecPrint();
proc.TableName = item;
proc.Execute();
_currentReportFile = proc.ReportFile;
ExecPrint(proc.StandardOutput);
ExecPrint("Table " + item + " result: " + proc.ExitStatus);
ExecPrintSectionEnd();
}
}
