public void LookForFaces_IsFindingFaces2TypeFromRawText_FoundProperFaces()
{
SimpleWaveFrontService waveService = new SimpleWaveFrontService(obj);
var facesIndicies = waveService.LookForFaces(2);
bool CompareResult =
(util.Compare(facesIndicies[0], new Face()
{
VertIndicies = new List <int>()
{
6, 4, 0
},
}) == 1)
&&
(util.Compare(facesIndicies[1], new Face()
{
VertIndicies = new List <int>()
{
1, 3, 4
},
}) == 1);
Assert.True(CompareResult);
}
public void SpecialFieldsClassTest()
{
SpecialFields obj1 = new SpecialFields();
obj1.Setup();
byte[] bytes = _serializer.Serialize(obj1);
SpecialFields obj2 = _serializer.Deserialize <SpecialFields>(bytes);
if (!_compare.Compare(obj1, obj2))
{
throw new Exception(_compare.DifferencesString);
}
}
public void PrimitiveFieldsNullableClassTest()
{
PrimitiveFieldsNullable obj1 = new PrimitiveFieldsNullable();
obj1.Setup();
byte[] bytes = _serializer.Serialize(obj1);
obj1.ClearStatic();
PrimitiveFieldsNullable obj2 = _serializer.Deserialize <PrimitiveFieldsNullable>(bytes);
if (!_compare.Compare(obj1, obj2))
{
throw new Exception(_compare.DifferencesString);
}
}
static void Main(string[] args)
{
CompareObjects compareObjects = new CompareObjects();
var jane = new Person {
Name = "Jane", DateCreated = DateTime.Now
};
var mary = new Person {
Name = "Mary", DateCreated = DateTime.Now
};
var jack = new Person {
Name = "Jack", DateCreated = DateTime.Now
};
var nameList1 = new List <Person>()
{
jane, mary, jack
};
var nameList2 = new List <Person>()
{
jane, jack, mary
};
var class1 = new ListClass <Person>(nameList1);
var class2 = new ListClass <Person>(nameList2);
compareObjects.IgnoreCollectionOrder = true;
compareObjects.Compare(class1, class2);
Console.WriteLine(compareObjects.Differences.Count);
Console.WriteLine(compareObjects.DifferencesString);
Console.ReadLine();
}
public void Template_InsertTemplate_SucessfullyInserted()
{
//Arrange
Fixture fixture = new Fixture();
var temp = fixture.CreateAnonymous <Template>();
//Template temp = new Template
// {
// Name = "welcome",
// Body = "Dear [FirstName], I'm glad you could join our family. Best Regards, Chuck Conway",
// Title = "Welcome to Momntz"
// };
//Act
Sessions.Artifact.Save(temp);
Sessions.Artifact.Flush();
Template temp2 = Sessions.Artifact.QueryOver <Template>()
.Where((u) => u.Name == temp.Name)
.SingleOrDefault();
//Assert
CompareObjects compare = new CompareObjects();
bool equal = compare.Compare(temp, temp2);
Assert.IsTrue(equal);
}
public void JsonSerializer_BasicUsage()
{
TestData truthData = new TestData
{
BoolValue = true,
IntValue = 777777777,
DoubleValue = 777777.777777,
StringValue = "My String Data 7777"
};
// Serilize and Deserialize
string serializedData = JsonSerializer.Serialize(truthData);
TestData deserializedData = JsonSerializer.DeserializeObject(serializedData, typeof(TestData)) as TestData;
// Compare they should be the same
CompareObjects comparer = new CompareObjects();
Assert.IsTrue(comparer.Compare(truthData, deserializedData));
// USING GENERICS! Serilize and Deserialize
serializedData = JsonSerializer.Serialize(truthData);
deserializedData = JsonSerializer.DeserializeObject <TestData>(serializedData);
// Compare they should be the same
comparer = new CompareObjects();
Assert.IsTrue(comparer.Compare(truthData, deserializedData));
}
public static List <string> GetChangedProperties <T>(this Delta <T> value, T original, List <String> includeList = null) where T : class, new()
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (original == null)
{
throw new ArgumentNullException("original");
}
var changedProperties = value.GetChangedPropertyNames();
if (!changedProperties.Any())
{
return(new List <string>());
}
var compareObjects = new CompareObjects {
MaxDifferences = 100,
ElementsToInclude = includeList ?? value.GetChangedPropertyNames().ToList()
};
compareObjects.ElementsToInclude.Add(typeof(T).Name);
bool result = compareObjects.Compare(original, value.GetEntity());
return(!result?compareObjects.Differences.Select(d => d.PropertyName).Distinct().ToList() : new List <string>());
}
public void TestGroupSerializationDeserialization()
{
var sop1 = SceneUtil.RandomSOP("Root", 1);
var sop2 = SceneUtil.RandomSOP("Child1", 2);
var sop3 = SceneUtil.RandomSOP("Child2", 3);
SceneObjectGroup group = new SceneObjectGroup(sop1);
group.AddPart(sop2);
group.AddPart(sop3);
SceneObjectGroup deserGroup = null;
string grpBytes = null;
Assert.DoesNotThrow(() =>
{
grpBytes = SceneObjectSerializer.ToXml2Format(group, true);
});
Assert.NotNull(grpBytes);
Assert.DoesNotThrow(() =>
{
deserGroup = SceneObjectSerializer.FromXml2Format(grpBytes);
});
CompareObjects comp = new CompareObjects();
comp.CompareStaticFields = false;
comp.CompareStaticProperties = false;
comp.ElementsToIgnore = PrimCompareIgnoreList;
Assert.IsTrue(comp.Compare(group, deserGroup), comp.DifferencesString);
}
public object CreateObject(string typeName, bool isSingleton = false, params object[] parameters)
{
var type = Type.GetType(typeName, true);
if (isSingleton)
{
List <KeyValuePair <object[], object> > existingInsts;
if (_instances.TryGetValue(type, out existingInsts) && existingInsts != null)
{
var compareObjects = new CompareObjects();
var instance = existingInsts.FirstOrDefault(ei => compareObjects.Compare(ei.Key, parameters));
if (!instance.Equals(default(KeyValuePair <object[], object>)))
{
return(instance.Value);
}
}
else
{
existingInsts = new List <KeyValuePair <object[], object> >();
_instances.Add(type, existingInsts);
}
var newInst = Activator.CreateInstance(type, parameters);
existingInsts.Add(new KeyValuePair <object[], object>(parameters, newInst));
return(newInst);
}
return(Activator.CreateInstance(type, parameters));
}
public void TestPartSerialzationDeserialization()
{
SceneObjectPart rootPart = new SceneObjectPart(UUID.Zero, new OpenSim.Framework.PrimitiveBaseShape(), new Vector3(1, 2, 3), Quaternion.Identity, Vector3.Zero, false);
rootPart.Name = "RootPart";
SceneObjectPart part = Util.RandomSOP("ChildPart", 2);
var pgrp1 = new SceneObjectGroup(rootPart);
pgrp1.AddPart(part);
part.InventorySerial = 1;
part.Rezzed = DateTime.Now;
part.TextColor = System.Drawing.Color.FromArgb(1, 2, 3, 4);
byte[] bytes = serEngine.SceneObjectSerializer.SerializePartToBytes(part, OpenSim.Region.Framework.Scenes.Serialization.SerializationFlags.None);
SceneObjectPart rootPart2 = new SceneObjectPart(UUID.Zero, new OpenSim.Framework.PrimitiveBaseShape(), new Vector3(1, 2, 3), Quaternion.Identity, Vector3.Zero, false);
rootPart2.Name = "RootPart2";
SceneObjectPart deserPart = serEngine.SceneObjectSerializer.DeserializePartFromBytes(bytes);
var pgrp2 = new SceneObjectGroup(rootPart2);
pgrp2.AddPart(deserPart);
deserPart.Rezzed = part.Rezzed;
CompareObjects comp = new CompareObjects();
comp.CompareStaticFields = false;
comp.CompareStaticProperties = false;
comp.ElementsToIgnore = PrimCompareIgnoreList;
Assert.IsTrue(comp.Compare(part, deserPart), comp.DifferencesString);
}
public void TestBaseSerializeDeserialize()
{
AssetBase baseAsset = new AssetBase();
baseAsset.Data = new byte[] { 0xA, 0x9, 0x8, 0x7, 0x6, 0x5, 0xA, 0x9, 0x8, 0x7, 0x6, 0x5 };
baseAsset.Name = "Name";
baseAsset.Description = "Description";
baseAsset.FullID = UUID.Random();
baseAsset.Local = true;
baseAsset.Temporary = true;
baseAsset.Type = 5;
baseAsset.Metadata.CreationDate = DateTime.Now;
StratusAsset stAsset2;
using (MemoryStream ms = new MemoryStream())
{
ProtoBuf.Serializer.Serialize <StratusAsset>(ms, StratusAsset.FromAssetBase(baseAsset));
ms.Position = 0;
stAsset2 = ProtoBuf.Serializer.Deserialize <StratusAsset>(ms);
}
var deserBase = stAsset2.ToAssetBase();
CompareObjects comp = new CompareObjects();
comp.CompareStaticFields = false;
comp.CompareStaticProperties = false;
Assert.IsTrue(comp.Compare(deserBase, baseAsset), comp.DifferencesString);
}
public void TestBasicCacheRetrieval()
{
Cache.DiskWriteBackCache wbc = new Cache.DiskWriteBackCache();
AssetBase baseAsset = new AssetBase();
baseAsset.Data = new byte[] { 0xA, 0x9, 0x8, 0x7, 0x6, 0x5, 0xA, 0x9, 0x8, 0x7, 0x6, 0x5 };
baseAsset.Name = "Name";
baseAsset.Description = "Description";
baseAsset.FullID = UUID.Random();
baseAsset.Local = true;
baseAsset.Temporary = true;
baseAsset.Type = 5;
baseAsset.Metadata.CreationDate = DateTime.Now;
var stAsset = StratusAsset.FromAssetBase(baseAsset);
wbc.StoreAsset(stAsset);
CompareObjects comp = new CompareObjects();
comp.CompareStaticFields = false;
comp.CompareStaticProperties = false;
var cacheAsset = wbc.GetAsset(baseAsset.FullID.Guid);
Assert.IsTrue(comp.Compare(cacheAsset, stAsset), comp.DifferencesString);
CollectionAssert.AreEqual(cacheAsset.Data, stAsset.Data);
}
internal void SelectTemplate(object value)
{
_updating = true;
try {
var co = new CompareObjects();
if (value != null)
{
foreach (var itm in _items.Where(i => i.Object != null))
{
if (co.Compare(itm.Object, value))
{
cbTemps.SelectedValue = itm.Object;
}
}
}
else
{
cbTemps.SelectedIndex = 0;
}
} finally {
_updating = false;
}
}
public void TestSimpleSerializeDeserialize()
{
StratusAsset stAsset1 = new StratusAsset();
stAsset1.Data = new byte[] { 0xA, 0x9, 0x8, 0x7, 0x6, 0x5, 0xA, 0x9, 0x8, 0x7, 0x6, 0x5 };
stAsset1.Name = "Name";
stAsset1.Description = "Description";
stAsset1.Id = UUID.Random().Guid;
stAsset1.Local = true;
stAsset1.Temporary = true;
stAsset1.Type = 5;
stAsset1.CreateTime = DateTime.Now;
CompareObjects comp = new CompareObjects();
comp.CompareStaticFields = false;
comp.CompareStaticProperties = false;
StratusAsset stAsset2;
using (MemoryStream ms = new MemoryStream())
{
ProtoBuf.Serializer.Serialize <StratusAsset>(ms, stAsset1);
ms.Position = 0;
stAsset2 = ProtoBuf.Serializer.Deserialize <StratusAsset>(ms);
Assert.IsTrue(comp.Compare(stAsset1, stAsset2), comp.DifferencesString);
}
}
private void AssertModelsEquals(object originalModel, object returnedModel)
{
var compareObjects = new CompareObjects {
MaxDifferences = 10
};
Assert.IsTrue(compareObjects.Compare(originalModel, returnedModel), "Source model is not the same as returned model. {0}", compareObjects.DifferencesString);
}
public string Compare(object exptected, object actual)
{
if (_comparer.Compare(exptected, actual))
{
return(null);
}
return(_comparer.DifferencesString);
}
public void LookForTextureVertex_IsFindingTexVertexFromRawText_FoundProperTextVertexs()
{
SimpleWaveFrontService waveService = new SimpleWaveFrontService(obj);
var texVerts = waveService.LookForTextureVertex();
bool CompareResult =
(util.Compare(texVerts[0], new TextureVertex()
{
XAxis = 0.5f, YAxis = 0.2f
}) == 1) &&
(util.Compare(texVerts[1], new TextureVertex()
{
XAxis = 0.35f, YAxis = 0.4f
}) == 1);
Assert.True(CompareResult);
}
public void LookForNomals_IsFindingNormalsFromRawText_FoundProperNormals()
{
SimpleWaveFrontService waveService = new SimpleWaveFrontService(obj);
var normals = waveService.LookForNormals();
bool CompareResult =
(util.Compare(normals[0], new Normal()
{
XAxis = 0, YAxis = -1, ZAxis = 0
}) == 1) &&
(util.Compare(normals[1], new Normal()
{
XAxis = 0, YAxis = 1, ZAxis = 0
}) == 1);
Assert.True(CompareResult);
}
public static void ShouldBeEqualTo(this ISomeServiceComplexRequest m1, ISomeServiceComplexRequest m2)
{
var comparer = new CompareObjects();
comparer.ElementsToIgnore.Add("IsPooled");
if (!comparer.Compare(m1, m2))
{
throw new Exception("Messages are not equal, Details:" + comparer.DifferencesString);
}
}
public void CompareUnmatchedParents()
{
var parent1 = new Parent("Parent1", 1, 2);
var parent2 = new Parent("Parent2", 1, 2);
var comparer = new CompareObjects();
bool compare = comparer.Compare(parent1, parent2);
Assert.IsTrue(compare, comparer.DifferencesString);
}
public void TestCFTimeoutAndWritePathWithImmediateStaleDeletes()
{
if (!_runTests)
{
return;
}
//delete any leftover files in the writeback cache
foreach (var file in Directory.EnumerateFiles("cache/cf_writeback"))
{
File.Delete(file);
}
AssetBase baseAsset = new AssetBase();
baseAsset.Data = new byte[] { 0xA, 0x9, 0x8, 0x7, 0x6, 0x5, 0xA, 0x9, 0x8, 0x7, 0x6, 0x5 };
baseAsset.Name = "Name";
baseAsset.Description = "Description";
baseAsset.FullID = UUID.Random();
baseAsset.Local = true;
baseAsset.Temporary = true;
baseAsset.Type = 5;
baseAsset.Metadata.CreationDate = DateTime.Now;
try
{
Config.Settings.Instance.UnitTest_ThrowTimeout = true;
Config.Settings.Instance.UnitTest_DeleteOldCacheFilesImmediately = true;
_client.StoreAsset(baseAsset);
System.Threading.Thread.Sleep(5000);
//confirm the asset is now missing from the writeback cache
Assert.IsNull(_client.DiskWriteBackCache.GetAsset(baseAsset.FullID.Guid));
}
finally
{
Config.Settings.Instance.UnitTest_ThrowTimeout = false;
Config.Settings.Instance.UnitTest_DeleteOldCacheFilesImmediately = false;
}
//we should now be able to get the asset from CF since it should've been written back
//by the write back recovery code
AssetBase cfAsset = _client.RequestAssetSync(baseAsset.FullID);
CompareObjects comp = new CompareObjects();
comp.CompareStaticFields = false;
comp.CompareStaticProperties = false;
Assert.IsTrue(comp.Compare(baseAsset, cfAsset), comp.DifferencesString);
CollectionAssert.AreEqual(baseAsset.Data, cfAsset.Data);
}
public void SerializationDeserializationTest()
{
Serializer serializer = new Serializer();
//Serialize and Deserialize a simple type
DateTime date = new DateTime(2010, 8, 21, 10, 53, 31, 555);
byte[] serializedDate = serializer.Serialize(date);
DateTime dateCopy = serializer.Deserialize <DateTime>(serializedDate);
//Serialize and Deserialize a single object
Person person = new Person();
person.Name = "John";
byte[] serialized = serializer.Serialize(person);
Person personCopy = serializer.Deserialize <Person>(serialized);
//Serialize and Deserialize a List
List <Person> personList = new List <Person>();
Person person1 = new Person();
person1.Name = "Sally";
personList.Add(person1);
Person person2 = new Person();
person2.Name = "Susan";
personList.Add(person2);
byte[] serializedList = serializer.Serialize(personList);
List <Person> personListCopy = serializer.Deserialize <List <Person> >(serializedList);
Assert.IsTrue(_compareObjects.Compare(person, personCopy));
Assert.IsTrue(_compareObjects.Compare(personList, personListCopy));
Assert.AreEqual(date, dateCopy);
}
public void CompareMatchedParents()
{
var parent1 = new Parent("Parent1", 1, 2);
var parent2 = new Parent("Parent1", 1, 2);
var comparer = new CompareObjects();
AddIgnoreElements(comparer, "Key");
bool compare = comparer.Compare(parent1, parent2);
Assert.IsTrue(compare, comparer.DifferencesString);
}
public int GenerateConstraintId <TEvent>(IConstraintInfo constraint)
{
var eventType = typeof(TEvent);
if (!eventConstraints.ContainsKey(eventType))
{
return(GenerateNewConstraintId <TEvent>(constraint));
}
var existing = eventConstraints[eventType].FirstOrDefault(c => comparer.Compare(constraint.GetConstraint(), c.GetConstraint()));
return(existing != null ? existing.Id : GenerateNewConstraintId <TEvent>(constraint));
}
static void CompareActualAndExpectedThens(IComponentContext scope, IEnumerable <Tuple <string, object> > thens)
{
var unitOfWork = scope.Resolve <UnitOfWork>();
var actualEvents = unitOfWork.GetChanges().Single().Root.GetChanges().ToArray();
var expectedEvents = thens.Select(item => item.Item2).ToArray();
var comparer = new CompareObjects {
MaxDifferences = Int32.MaxValue
};
if (!comparer.Compare(actualEvents, expectedEvents))
{
NUnit.Framework.Assert.Fail(comparer.DifferencesString);
}
}
public void TestCoalescedSerializationDeserialization()
{
var sop1 = Util.RandomSOP("Root", 1);
var sop2 = Util.RandomSOP("Child1", 2);
var sop3 = Util.RandomSOP("Child2", 3);
SceneObjectGroup group = new SceneObjectGroup(sop1);
group.AddPart(sop2);
group.AddPart(sop3);
var sop4 = Util.RandomSOP("Root2", 1);
var sop5 = Util.RandomSOP("Child12", 2);
var sop6 = Util.RandomSOP("Child22", 3);
SceneObjectGroup group2 = new SceneObjectGroup(sop4);
group2.AddPart(sop5);
group2.AddPart(sop6);
var gp1perms = group.GetNewItemPermissions(UUID.Random());
var gp2perms = group2.GetNewItemPermissions(UUID.Random());
var perms = new Dictionary <UUID, ItemPermissionBlock>();
perms[group.UUID] = gp1perms;
perms[group2.UUID] = gp2perms;
CoalescedObject cobj = new CoalescedObject(
new List <SceneObjectGroup> {
group, group2
},
perms
);
var colbytes = serEngine.CoalescedObjectSerializer.SerializeObjectToBytes(cobj, SerializationFlags.None);
var deserColObj = serEngine.CoalescedObjectSerializer.DeserializeObjectFromBytes(colbytes);
CompareObjects comp = new CompareObjects();
comp.CompareStaticFields = false;
comp.CompareStaticProperties = false;
comp.ElementsToIgnore = PrimCompareIgnoreList;
Assert.IsTrue(comp.Compare(cobj, deserColObj), comp.DifferencesString);
}
public void CompareIgnoreChildParents()
{
var parent1 = new Parent("Parent1", 1, 2);
parent1.AddChild("Child1", 1);
var parent2 = new Parent("Parent1", 1, 2);
var comparer = new CompareObjects();
AddIgnoreElements(comparer, "Key", "m_Children");
bool compare = comparer.Compare(parent1, parent2);
Assert.IsTrue(compare, comparer.DifferencesString);
}
public void CompareWidgetTest()
{
DataSet ds = CreateDataSet("Fruits", "Apple", "Orange", "Bananna");
Widget w1 = new Widget(true, true, ds);
Widget w2 = new Widget(true, true, ds);
_compare.CompareChildren = true;
_compare.CompareFields = true;
_compare.ComparePrivateFields = true;
_compare.ComparePrivateProperties = true;
_compare.CompareProperties = true;
_compare.CompareReadOnly = true;
//_compare.TypesToIgnore.Add(typeof(System.Reflection.Pointer));
//_compare.TypesToIgnore.Add(typeof(System.IntPtr));
_compare.AddCustomComparer(typeof(DataSet), CompareDataSet);
//_compare.TypeSpecificCompareOptions.Add(
// typeof(DataSet),
// new TypeSpecificCompareOptions(false, false, true, true, true, true));
//_compare.ElementsToIgnore.Add("CultureInfo");
//_compare.ElementsToIgnore.Add("Pointer");
//_compare.ElementsToIgnore.Add("DefaultViewManager");
//_compare.ElementsToIgnore.Add("dataViewManager");
//_compare.ElementsToIgnore.Add("DataViewManagerListItemTypeDescriptor");
//_compare.ElementsToIgnore.Add("Locale");
//_compare.ElementsToIgnore.Add("Relations");
//_compare.ElementsToIgnore.Add("Tables");
//_compare.ElementsToIgnore.Add("EventHandlerList");
//_compare.ElementsToIgnore.Add("DataTableCollection");
//_compare.ElementsToIgnore.Add("DataSetRelationCollection");
bool compare = _compare.Compare(w1, w2);
Assert.IsTrue(compare, _compare.DifferencesString);
// Set back to the defaults
_compare.CompareChildren = true;
_compare.CompareFields = true;
_compare.ComparePrivateFields = false;
_compare.ComparePrivateProperties = false;
_compare.CompareProperties = true;
_compare.CompareReadOnly = true;
}
public void TestWriteAndRetrieveLargeAssets()
{
if (!_runTests)
{
return;
}
Random random = new Random();
AssetBase baseAsset = new AssetBase();
var arr = new byte[1 * 1024 * 1024];
random.NextBytes(arr);
baseAsset.Data = arr;
baseAsset.Name = "Name1234567 ΏΏ";
baseAsset.Description = "Description TEstttt ΏΏΏÿÿ";
baseAsset.FullID = UUID.Random();
baseAsset.Local = true;
baseAsset.Temporary = true;
baseAsset.Type = 5;
baseAsset.Metadata.CreationDate = DateTime.Now;
int start = Environment.TickCount;
_client.StoreAsset(baseAsset);
Console.WriteLine("Time to store: {0}", Environment.TickCount - start);
start = Environment.TickCount;
AssetBase cfAsset = _client.RequestAssetSync(baseAsset.FullID);
Console.WriteLine("Time to read: {0}", Environment.TickCount - start);
CompareObjects comp = new CompareObjects();
comp.CompareStaticFields = false;
comp.CompareStaticProperties = false;
Assert.IsTrue(comp.Compare(baseAsset, cfAsset), comp.DifferencesString);
CollectionAssert.AreEqual(baseAsset.Data, cfAsset.Data);
start = Environment.TickCount;
//cleanup
_client.PurgeAssetSync(baseAsset.FullID);
Console.WriteLine("Time to purge: {0}", Environment.TickCount - start);
}
public void TestWriteToCF()
{
if (!_runTests)
{
return;
}
//delete any leftover files in the writeback cache
foreach (var file in Directory.EnumerateFiles("cache/cf_writeback"))
{
File.Delete(file);
}
Cache.DiskWriteBackCache wbc = new Cache.DiskWriteBackCache();
AssetBase baseAsset = new AssetBase();
baseAsset.Data = new byte[] { 0xA, 0x9, 0x8, 0x7, 0x6, 0x5, 0xA, 0x9, 0x8, 0x7, 0x6, 0x5 };
baseAsset.Name = "Name";
baseAsset.Description = "Description";
baseAsset.FullID = UUID.Random();
baseAsset.Local = true;
baseAsset.Temporary = true;
baseAsset.Type = 5;
baseAsset.Metadata.CreationDate = DateTime.Now;
var stAsset = StratusAsset.FromAssetBase(baseAsset);
wbc.StoreAsset(stAsset);
wbc.DoWriteCycle();
//the asset should still be in the WB cache
Assert.IsNotNull(wbc.GetAsset(baseAsset.FullID.Guid));
//... but we should now be able to get the asset from CF
AssetBase cfAsset = _client.RequestAssetSync(baseAsset.FullID);
CompareObjects comp = new CompareObjects();
comp.CompareStaticFields = false;
comp.CompareStaticProperties = false;
Assert.IsTrue(comp.Compare(baseAsset, cfAsset), comp.DifferencesString);
CollectionAssert.AreEqual(baseAsset.Data, cfAsset.Data);
}
// Case 1628: 1.1.05.05_Call getGenericInstanceInfo to check the Dicom_Info for dicom instance
public void Run_GenericInstance_GetInfoForDICOM_Case1628()
{
int runCount = 0;
foreach (InputDataSet ids in this.Input.DataSets)
{
runCount++;
Round r = this.NewRound(runCount.ToString(), ids.Description);
try
{
string instanceUID = string.Empty;
for (int i = 0; i < ids.InputParameters.Count; i++)
{
if (ids.InputParameters.GetParameter(i).Step == "getInstanceInfo")
{
if (ids.InputParameters.GetParameter(i).Key == "instanceID")
{
instanceUID = ids.InputParameters.GetParameter(i).Value;
}
}
}
string epCode = string.Empty;
string epMessage = string.Empty;
GenericGetGenericInstanceInfoResponseType epGetGenericInstanceInfo = new GenericGetGenericInstanceInfoResponseType();
epGetGenericInstanceInfo.instance = new InstanceType();
epGetGenericInstanceInfo.instance.dicomInfo = new DicomInfoType();
for (int i = 0; i < ids.ExpectedValues.Count; i++)
{
switch (ids.ExpectedValues.GetParameter(i).Key)
{
case "code":
epCode = ids.ExpectedValues.GetParameter(i).Value;
break;
case "message":
epMessage = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_modality":
epGetGenericInstanceInfo.instance.dicomInfo.modality = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_acquisitionDate":
epGetGenericInstanceInfo.instance.dicomInfo.acquisitionDate = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_acquisitionTime":
epGetGenericInstanceInfo.instance.dicomInfo.acquisitionTime = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_patientFirstName":
epGetGenericInstanceInfo.instance.dicomInfo.patientFirstName = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_patientLastName":
epGetGenericInstanceInfo.instance.dicomInfo.patientLastName = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_patientId":
epGetGenericInstanceInfo.instance.dicomInfo.patientId = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_patientBirthDate":
epGetGenericInstanceInfo.instance.dicomInfo.patientBirthDate = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_patientAge":
epGetGenericInstanceInfo.instance.dicomInfo.patientAge = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_studyDate":
epGetGenericInstanceInfo.instance.dicomInfo.studyDate = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_kvp":
epGetGenericInstanceInfo.instance.dicomInfo.kvp = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_xrayTubeCurrent":
epGetGenericInstanceInfo.instance.dicomInfo.xrayTubeCurrent = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_exposureTime":
epGetGenericInstanceInfo.instance.dicomInfo.exposureTime = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_sopClassUid":
epGetGenericInstanceInfo.instance.dicomInfo.sopClassUid = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_instanceNumber":
epGetGenericInstanceInfo.instance.dicomInfo.instanceNumber = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_manufacturerModelName":
epGetGenericInstanceInfo.instance.dicomInfo.manufacturerModelName = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_imagerPixelSpacing":
epGetGenericInstanceInfo.instance.dicomInfo.imagerPixelSpacing = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_transferSyntax":
epGetGenericInstanceInfo.instance.dicomInfo.transferSyntax = ids.ExpectedValues.GetParameter(i).Value;
break;
case "dcm_anatomicRegion":
epGetGenericInstanceInfo.instance.dicomInfo.anatomicRegion = ids.ExpectedValues.GetParameter(i).Value;
break;
default:
break;
}
}
GenericIntanceServiceV2 genericInstanceSvc = new GenericIntanceServiceV2();
CheckPoint cpGetGenericInstanceInfo = new CheckPoint("getGenericInstanceInfo", "getGenericInstanceInfo");
r.CheckPoints.Add(cpGetGenericInstanceInfo);
GenericGetGenericInstanceInfoResponseType rtGetGenericInstanceInfo = genericInstanceSvc.getGenericInstanceInfo(instanceUID);
if (!genericInstanceSvc.LastReturnXMLValidateResult.isValid)
{
cpGetGenericInstanceInfo.Result = TestResult.Fail;
cpGetGenericInstanceInfo.Outputs.AddParameter("getGenericInstanceInfo", "Invalid XML", "GetGenericInstanceInfo response is not complied with schema. Actually get: " + genericInstanceSvc.LastReturnXML);
SaveRound(r);
continue;
}
if (rtGetGenericInstanceInfo.status.code != 0)
{
cpGetGenericInstanceInfo.Result = TestResult.Fail;
cpGetGenericInstanceInfo.Outputs.AddParameter("getGenericInstanceInfo", "Get Fail", "Get Fail.Code:" + rtGetGenericInstanceInfo.status.code.ToString() + " Message:" + rtGetGenericInstanceInfo.status.message);
SaveRound(r);
continue;
}
CompareObjects compareObjects = new CompareObjects();
if (compareObjects.Compare(epGetGenericInstanceInfo.instance.dicomInfo, rtGetGenericInstanceInfo.instance.dicomInfo))
{
cpGetGenericInstanceInfo.Result = TestResult.Pass;
cpGetGenericInstanceInfo.Outputs.AddParameter("getGenericInstanceInfo", "Check the DICOM Info", "The return value is equal to expected value" + genericInstanceSvc.LastReturnXML);
}
else
{
cpGetGenericInstanceInfo.Result = TestResult.Fail;
cpGetGenericInstanceInfo.Outputs.AddParameter("getGenericInstanceInfo", "Check the DICOM Info", "Fail. The return values is not equal to expected value." + compareObjects.DifferencesString + ". Actually get: " + genericInstanceSvc.LastReturnXML);
SaveRound(r);
continue;
}
SaveRound(r);
}
catch (Exception ex)
{
CheckPoint cp = new CheckPoint();
r.CheckPoints.Add(cp);
cp.Result = TestResult.Fail;
cp.Outputs.AddParameter("Exception thrown", "Exception Message", ex.Message);
SaveRound(r);
}
}
Output();
}