| private Compare ( object object1, object object2 ) : bool | ||
| object1 | object | |
| object2 | object | |
| return | bool | |
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 Ingredients_PersistanceTest()
{
var compare = new CompareObjects();
compare.IgnoreObjectTypes = true;
InAutoRollbackTransaction(uof =>
{
Ingredient ing = new Ingredient { StockQuantity = 1, PricePerUnit = 0.1M, NormalWeight = 1, Name = "ING", ExtraWeight = 2, Recipies = new List<Recipe>() };
uof.Db.Ingredients.Insert(ing);
uof.Db.Commit();
uof.Db.ObjectContext().DetachAll();
Ingredient ing2 = uof.Db.Ingredients.Get(ing.IngredientID);
Assert.IsTrue(ing != ing2);
Assert.IsTrue(compare.Compare(ing, ing2));
ing2.Name = "ING2";
uof.Db.Commit();
uof.Db.ObjectContext().DetachAll();
ing = uof.Db.Ingredients.Get(ing.IngredientID);
Assert.IsTrue(ing != ing2);
Assert.IsFalse(compare.Compare(ing, ing2));
});
}
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 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 given_a_GET_request_for_session_speakers_it_returns_speakers()
{
var speakers = GetConferenceSessionSpeakers(codemashs.slug, phonegap.slug);
var compareObjects = new CompareObjects();
var areSame = compareObjects.Compare(speakers, phonegap.speakers);
if (!areSame)
{
Assert.Fail(compareObjects.DifferencesString);
}
}
public void given_a_GET_request_for_a_single_session_it_returns_a_session_with_child_collections()
{
var session = GetConferenceSession(codemashs.slug, phonegap.slug);
var compareObjects = new CompareObjects();
var areSame = compareObjects.Compare(session, phonegap);
if (!areSame)
{
Assert.Fail(compareObjects.DifferencesString);
}
}
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 given_a_GET_request_for_conference_speakers_it_returns_all_speakers()
{
var speakers = GetConferenceSpeakers(codemashs.slug);
var compareObjects = new CompareObjects();
var areSame = compareObjects.Compare(speakers.Count, 100);
if (!areSame)
{
Assert.Fail(compareObjects.DifferencesString);
}
}
public void given_a_GET_request_for_resources_it_returns_resources()
{
var resources = GetConferenceSessionResources(codemashs.slug, phonegap.slug);
var compareObjects = new CompareObjects();
var areSame = compareObjects.Compare(resources, new List<string>());
if (!areSame)
{
Assert.Fail(compareObjects.DifferencesString);
}
}
public void given_a_GET_request_for_a_single_conference_it_returns_general_info_with_a_link_to_sessions()
{
var conference = GetConference(new ConferencesRequest() { conferenceSlug = codemash.slug } );
var compareObjects = new CompareObjects();
var areSame = compareObjects.Compare(conference, codemash);
if (!areSame)
{
Assert.Fail(compareObjects.DifferencesString);
}
}
public void given_a_GET_request_for_a_single_conference_sessions_it_returns_sessions_with_speakers()
{
var sessions = GetConferenceSessions(codemashs.slug);
var compareObjects = new CompareObjects();
var areSame = compareObjects.Compare(sessions.Count, 156);
if (!areSame)
{
Assert.Fail(compareObjects.DifferencesString);
}
}
public void given_a_GET_request_for_a_single_session_speaker_it_returns_the_speaker()
{
var speaker = GetConferenceSessionSpeaker(codemashs.slug, phonegap.slug, andrewGlover.slug);
var compareObjects = new CompareObjects();
var areSame = compareObjects.Compare(speaker, andrewGlover);
if (!areSame)
{
Assert.Fail(compareObjects.DifferencesString);
}
}
public void given_a_GET_request_for_all_conferences_it_returns_subset_of_conference_info()
{
//GetConferences().FirstOrDefault().IsTheSameAs(codemashs).ShouldBeTrue();
var conference = GetConferences(new ConferencesRequest()).FirstOrDefault();
var compareObjects = new CompareObjects();
var areSame = compareObjects.Compare(conference, codemashs);
if (!areSame)
{
Assert.Fail(compareObjects.DifferencesString);
}
}
public void given_a_GET_request_for_a_schedule_it_returns_the_schedule_with_sessions()
{
//GetConferences().FirstOrDefault().IsTheSameAs(codemashs).ShouldBeTrue();
var schedule = GetSchedule(new ScheduleRequest() { conferenceSlug = "CodeMash-2012", userSlug = "rob-gibbens" });
var compareObjects = new CompareObjects();
var areSame = compareObjects.Compare(schedule, robsSchedule);
if (!areSame)
{
Assert.Fail(compareObjects.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 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);
}
/// <summary>
/// Performs a deep comparison and returns true if the objects are equal. Assert fails if they are not.
/// </summary>
/// <param name="expected">Expected value.</param>
/// <param name="actual">Actual value.</param>
public static void AreEqual(object expected, object actual)
{
CompareObjects comparer = new CompareObjects();
bool result = comparer.Compare(expected, actual);
// if they're different, list the differences
if (result == false)
{
StringBuilder message = new StringBuilder();
foreach (string difference in comparer.Differences)
message.Append(difference);
throw new AssertFailedException("Objects are not equal. " + message.ToString());
}
}
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 DocumentationTest()
{
//This is the comparison class
CompareObjects compareObjects = new CompareObjects();
//Create a couple objects to compare
Person person1 = new Person();
person1.DateCreated = DateTime.Now;
person1.Name = "Greg";
Person person2 = new Person();
person2.Name = "John";
person2.DateCreated = person1.DateCreated;
//These will be different, write out the differences
if (!compareObjects.Compare(person1, person2))
Console.WriteLine(compareObjects.DifferencesString);
}
private void CompareRecordInfo(IRecordInfo recordInfo1, IRecordInfo recordInfo2)
{
var comp = new CompareObjects();
comp.CompareChildren = true;
comp.ElementsToIgnore.Add("Cache");
comp.ElementsToIgnore.Add("RecordType");
comp.ElementsToIgnore.Add("FieldTypeInternal");
comp.ElementsToIgnore.Add("FieldInfo");
comp.ElementsToIgnore.Add("Operations");
comp.ElementsToIgnore.Add("FieldType");
comp.ElementsToIgnore.Add("TypeId");
comp.CompareFields = true;
//comp.ComparePrivateFields = true;
comp.ComparePrivateProperties = true;
comp.CompareReadOnly = true;
Check.That(comp.Compare(recordInfo1, recordInfo2)).IsTrue();
}
public void TestGroupInventorySerializationDeserialization()
{
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 grpBytes = serEngine.InventoryObjectSerializer.SerializeGroupToInventoryBytes(group, SerializationFlags.None);
SceneObjectGroup deserGroup = serEngine.InventoryObjectSerializer.DeserializeGroupFromInventoryBytes(grpBytes);
CompareObjects comp = new CompareObjects();
comp.CompareStaticFields = false;
comp.CompareStaticProperties = false;
comp.ElementsToIgnore = PrimCompareIgnoreList;
Assert.IsTrue(comp.Compare(group, deserGroup), comp.DifferencesString);
}
public void Test()
{
var newMessages = new List<object>();
var bus = new MessageBus();
bus.RegisterHandler<object>(newMessages.Add);
var eventStore = new InMemoryEventStore(bus, GivenTheseEvents());
var repository = new DomainRepository(eventStore);
RegisterHandler(bus, repository);
try
{
bus.Handle(WhenThisHappens());
}
catch(Exception e)
{
var expectedException = ThisExceptionShouldOccur();
if(expectedException == null)
Assert.Fail(e.Message);
if(expectedException.GetType().IsAssignableFrom(e.GetType()))
{
Assert.AreEqual(expectedException.Message, e.Message);
return;
}
Assert.Fail("Expected exception of type {0} with message {1} but got exception of type {2} with message {3}", expectedException.GetType(), expectedException.Message, e.GetType(), e.Message);
}
var expectedEvents = TheseEventsShouldOccur().ToList();
var comparer = new CompareObjects();
if(!comparer.Compare(expectedEvents, newMessages))
{
Assert.Fail(comparer.DifferencesString);
}
}
public SavedCommandItem AddCommand(object command, string serviceBus, string transport, string server, string queue)
{
SavedCommandItem item = null;
var co = new CompareObjects();
foreach( var c in _items ) {
if( co.Compare(c.SentCommand, command) ) {
item = c; // TODO: When we show what ServiceBus/Server/Queue the command has been sent to,
// then also compare those values
break;
}
}
if( item == null ) {
item = new SavedCommandItem(command.GetType().GetDisplayName(command).CutEnd(70), null, false, DateTime.Now);
SavedCommand2 cmd = new SavedCommand2();
cmd.Command = command;
cmd.ServiceBus = serviceBus;
cmd.Transport = transport;
cmd.Server = server;
cmd.Queue = queue;
item.SetCommand(cmd);
_items.Insert(0, item);
}
item.LastSent = DateTime.Now;
Save();
return item;
}
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);
}
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 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);
}
public void TestWriteAndRetrieveAssets()
{
if (!_runTests) return;
AssetBase baseAsset = new AssetBase();
baseAsset.Data = new byte[] { 0xA, 0x9, 0x8, 0x7, 0x6, 0x5, 0xA, 0x9, 0x8, 0x7, 0x6, 0x5 };
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 TestWriteThenReadManyTimes()
{
if (!_runTests) return;
Random random = new Random();
List<AssetBase> assets = new List<AssetBase>();
int start;
try
{
for (int i = 0; i < 25; i++)
{
AssetBase baseAsset = new AssetBase();
var arr = new byte[512 * 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;
start = Environment.TickCount;
_client.StoreAsset(baseAsset);
Console.WriteLine("Time to store: {0}", Environment.TickCount - start);
assets.Add(baseAsset);
}
// Use ConcurrentQueue to enable safe enqueueing from multiple threads.
var exceptions = new ConcurrentQueue<Exception>();
System.Threading.Tasks.Parallel.For(0, 10, i =>
{
try
{
foreach (var baseAsset in assets)
{
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);
}
}
catch (Exception e)
{
exceptions.Enqueue(e);
}
});
if (exceptions.Count > 0) throw new AggregateException(exceptions);
}
finally
{
foreach (var baseAsset in assets)
{
start = Environment.TickCount;
//cleanup
_client.PurgeAssetSync(baseAsset.FullID);
Console.WriteLine("Time to purge: {0}", Environment.TickCount - start);
}
}
}
public void TestWriteTHENRetrieveLargeAssets()
{
if (!_runTests) return;
Random random = new Random();
List<AssetBase> assets = new List<AssetBase>();
int start;
try
{
for (int i = 0; i < 25; i++)
{
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;
start = Environment.TickCount;
_client.StoreAsset(baseAsset);
Console.WriteLine("Time to store: {0}", Environment.TickCount - start);
assets.Add(baseAsset);
}
foreach (var baseAsset in assets)
{
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);
}
}
finally
{
foreach (var baseAsset in assets)
{
start = Environment.TickCount;
//cleanup
_client.PurgeAssetSync(baseAsset.FullID);
Console.WriteLine("Time to purge: {0}", Environment.TickCount - start);
}
}
}