public void SingletonInterceptors()
{
var object1 = (AbstractClass <int>)manager.GetInstance(typeof(AbstractClass <int>));
var object2 = (AbstractClass <int>)manager.GetInstance(typeof(AbstractClass <int>));
var object3 = (AbstractClass <int>)manager.GetInstance(typeof(AbstractClass <int>));
var object4 =
(AbstractClass <string>)manager.GetInstance(typeof(AbstractClass <string>));
var object5 =
(AbstractClass <string>)manager.GetInstance(typeof(AbstractClass <string>));
var object6 =
(AbstractClass <string>)manager.GetInstance(typeof(AbstractClass <string>));
Assert.AreSame(object1, object2);
Assert.AreSame(object1, object3);
Assert.AreSame(object4, object5);
Assert.AreSame(object4, object6);
Assert.AreNotSame(object1, object4);
}
public void PerformClusterTesting()
{
var cluster = new FakeCluster <FactorySimple0_Cluster>(
null
);
var af = cluster.Get <IAFactory>();
Assert.IsNotNull(af);
var a0 = af.Create();
Assert.IsNotNull(a0);
var a1 = af.Create();
Assert.IsNotNull(a1);
Assert.AreNotSame(a0, a1);
}
public void RegisterThenDispose()
{
var cts1 = new CancellationTokenSource();
var reg1 = cts1.Token.Register(() => { throw new ApplicationException(); });
var cts2 = new CancellationTokenSource();
var reg2 = cts2.Token.Register(() => { throw new ApplicationException(); });
Assert.AreNotEqual(cts1, cts2, "#1");
Assert.AreNotSame(cts1, cts2, "#2");
reg1.Dispose();
cts1.Cancel();
try {
cts2.Cancel();
Assert.Fail("#3");
} catch (AggregateException) {
}
}
public void testBestSequenceWithValidator()
{
var sequence = new[] { "1", "2", "3", "2", "1" };
var cg = new IdentityFeatureGenerator(sequence);
var outcomes = new[] { "1", "2", "3" };
var model = new IdentityModel(outcomes);
var bs = new BeamSearch <string>(2, cg, model, new SequenceValidator(), 0);
var seq = bs.BestSequence(sequence, null);
Assert.NotNull(seq);
Assert.AreEqual(sequence.Length, seq.Outcomes.Count);
Assert.AreEqual("1", seq.Outcomes[0]);
Assert.AreNotSame("2", seq.Outcomes[1]);
Assert.AreEqual("3", seq.Outcomes[2]);
Assert.AreNotSame("2", seq.Outcomes[3]);
Assert.AreEqual("1", seq.Outcomes[4]);
}
public void SetTest()
{
SEALContext context = GlobalContext.BFVContext;
KeyGenerator keygen = new KeyGenerator(context);
GaloisKeys keys = keygen.GaloisKeysLocal();
Assert.IsNotNull(keys);
Assert.AreEqual(24ul, keys.Size);
GaloisKeys keys2 = new GaloisKeys();
Assert.IsNotNull(keys2);
Assert.AreEqual(0ul, keys2.Size);
keys2.Set(keys);
Assert.AreNotSame(keys, keys2);
Assert.AreEqual(24ul, keys2.Size);
}
public void Can_add_new_product()
{
var product = new Product {
Name = "Apple", Category = "Fruits"
};
IProductRepository repository = new ProductRepository();
repository.Add(product);
// use session to try to load the product
using (ISession session = _sessionFactory.OpenSession())
{
var fromDb = session.Get <Product>(product.Id);
// Test that the product was successfully inserted
Assert.IsNotNull(fromDb);
Assert.AreNotSame(product, fromDb);
Assert.AreEqual(product.Name, fromDb.Name);
Assert.AreEqual(product.Category, fromDb.Category);
}
}
public void TestBasicRegistration()
{
var injector = new Injector();
injector.Register(OpenGenericBinding.For(typeof(IBasic <>)).To(typeof(Basic <>)));
var obj = injector.Resolve <IBasic <object> > ();
Assert.NotNull(obj);
Assert.AreEqual(typeof(Basic <object>), obj.GetType());
var obj2 = injector.Resolve <IBasic <object> > ();
Assert.AreNotSame(obj, obj2);
var ex = injector.Resolve <IBasic <Exception> > ();
Assert.NotNull(ex);
Assert.AreEqual(typeof(Basic <Exception>), ex.GetType());
}
public void TestVisualizerAssignment()
{
using (GuiManager guiManager = new GuiManager(new GameServiceContainer())) {
IGuiVisualizer visualizer = new DummyVisualizer();
try {
IGuiVisualizer newVisualizer = visualizer;
Assert.AreNotSame(newVisualizer, guiManager.Visualizer);
{
IGuiVisualizer oldVisualizer = guiManager.Visualizer;
guiManager.Visualizer = newVisualizer;
visualizer = oldVisualizer;
}
Assert.AreSame(newVisualizer, guiManager.Visualizer);
}
finally {
tryDispose(visualizer);
}
}
}
public void RemovePasses()
{
var pool = new ObjectPool <TestClass>(new TestInstanceCreator());
var obj = pool.PopOrCreate();
pool.Push(obj);
Assert.AreEqual(1, pool.Count);
pool.Remove(obj);
Assert.AreEqual(0, pool.Count);
var obj2 = pool.PopOrCreate();
Assert.AreNotSame(obj, obj2);
Assert.DoesNotThrow(() => {
pool.Remove(obj);
});
}
public void ResponseStreamWrapper_WrapResponseStream_Calls_StreamManipulators_After_Pipeline_Has_Finished()
{
InitialiseWrapper();
using (var originalStream = new MemoryStream()) {
_Environment.Response.Body = originalStream;
_Manipulator.ManipulateCallback = () => {
var actualStream = _Environment.Response.Body;
Assert.IsNotNull(actualStream);
Assert.AreNotSame(originalStream, actualStream);
Assert.IsTrue(_Pipeline.NextMiddlewareCalled);
};
_Pipeline.CallMiddleware(_Wrapper.WrapResponseStream, _Environment.Environment);
}
Assert.AreEqual(1, _Manipulator.ManipulateCallCount);
}
public void DeepCopyGraph()
{
// a cube
var graph = new UndirectedGraph(4);
graph.AddEdge(0, 1);
graph.AddEdge(1, 2);
graph.AddEdge(2, 3);
graph.AddEdge(3, 0);
graph.AddEdge(3, 3);
var graph2 = graph.DeepCopy();
Assert.AreEqual(graph.ToString(), graph2.ToString());
Assert.AreNotSame(graph, graph2);
graph.AddEdge(0, 2);
Assert.AreNotEqual(graph.ToString(), graph2.ToString());
Assert.AreNotSame(graph, graph2);
}
public void FuncTests_Resolve_ParameterInjection_Mixed2()
{
var container = new StashboxContainer();
container.Register <FuncTest5>();
container.Register <FuncTest6>();
container.Register <Dep2>();
container.Register <Dep4>();
var inst = container.Resolve <FuncTest5>();
var d3 = new Dep3();
var d = inst.Dep(d3);
var d32 = new Dep3();
Assert.IsNotNull(d.Dep(d32).Dep);
Assert.AreNotSame(d3, d.Dep(d32).Dep);
Assert.AreSame(d3, d.Dep1);
}
public void FuncTests_Resolve_ParameterInjection_Mixed()
{
var container = new StashboxContainer();
container.Register <FuncTest3>();
container.Register <FuncTest4>();
container.Register <Dep2>();
container.Register <Dep4>();
var inst = container.Resolve <FuncTest3>();
var d1 = new Dep1();
var d3 = new Dep3();
var d = inst.Dep(d1, d3);
var d12 = new Dep1();
Assert.AreNotSame(d1, d.Dep(d12).Dep);
Assert.AreSame(d12, d.Dep(d12).Dep);
}
public virtual void TestSingleBond()
{
var container = MakeSingleBond();
model.SetCompactAtom(true);
model.SetCompactShape(AtomShapeType.Oval);
model.SetShowEndCarbons(true);
// generate the single line element
var root = generator.Generate(container, model);
var elements = elementUtil.GetAllSimpleElements(root);
Assert.AreEqual(2, elements.Count);
// test that the endpoints are distinct
var ovalA = (OvalElement)elements[0];
var ovalB = (OvalElement)elements[1];
Assert.AreNotSame(0, Distance(ovalA.Coord, ovalB.Coord));
}
private static async Task Inner(Container container, ICommand command)
{
DisposableCommand cmd1, cmd2;
await Task.Yield();
cmd1 = container.GetInstance <DisposableCommand>();
Assert.AreSame(command, cmd1);
using (AsyncScopedLifestyle.BeginScope(container))
{
// Act
cmd2 = container.GetInstance <DisposableCommand>();
Assert.AreNotSame(command, cmd2);
Assert.IsFalse(cmd2.HasBeenDisposed);
}
Assert.IsTrue(cmd2.HasBeenDisposed);
}
public void BuildGenericRegistration()
{
var componentType = typeof(G <>);
var serviceType = typeof(IG <>);
var concreteServiceType = typeof(IG <int>);
var cb = new ContainerBuilder();
cb.RegisterGeneric(componentType)
.As(serviceType);
var c = cb.Build();
object g1 = c.Resolve(concreteServiceType);
object g2 = c.Resolve(concreteServiceType);
Assert.IsNotNull(g1);
Assert.IsNotNull(g2);
Assert.AreNotSame(g1, g2);
Assert.IsTrue(g1.GetType().GetGenericTypeDefinition() == componentType);
}
public void GetByID_TwoItems_ReturnsCorrectObject()
{
// Arrange
var id1 = Guid.NewGuid();
var id2 = Guid.NewGuid();
PCCustomEffect entity1 = new PCCustomEffect {
ID = id1
};
PCCustomEffect entity2 = new PCCustomEffect {
ID = id2
};
// Act
MessageHub.Instance.Publish(new OnCacheObjectSet <PCCustomEffect>(entity1));
MessageHub.Instance.Publish(new OnCacheObjectSet <PCCustomEffect>(entity2));
// Assert
Assert.AreNotSame(entity1, _cache.GetByID(id1));
Assert.AreNotSame(entity2, _cache.GetByID(id2));
}
public void CyclicObjectIsCopiedWithSemanticsIntact()
{
Node n1 = new Node();
n1.Name = "Node 1";
Node n2 = new Node();
n2.Name = "Node 2";
n1.Next = n2;
n2.Prev = n1;
Node n1c = (Node)n1.Copy();
Assert.AreNotSame(n1, n1c);
Assert.AreNotSame(n2, n1c.Next);
Assert.IsNotNull(n1c.Next);
Assert.AreEqual(n1.Name, n1c.Name);
Assert.AreEqual(n2.Name, n1c.Next.Name);
Assert.AreSame(n1c, n1c.Next.Prev);
}
public void CanCreateAMockTestServiceWithIndexedMockWhenThereAreMultipleDependenciesOfSameInterface_FirstPosition()
{
var mockTestInterface = new Mock <ITestInterface>();
var mockTestInterfaceObject = mockTestInterface.Object;
var mockedTestService =
Create
.MeA <TestServiceWithMultipleIdenticalDependencies>()
.UsingThisInstanceToMock <ITestInterface>(mockTestInterfaceObject)
.SpecificallyForTheArgumentAt(0)
.AndMockingAllTheOtherThings();
Assert.IsNotNull(mockedTestService);
Assert.IsInstanceOf <TestServiceWithMultipleIdenticalDependencies>(mockedTestService);
Assert.AreSame(mockedTestService.TestInterface1, mockTestInterfaceObject);
Assert.AreNotSame(mockedTestService.TestInterface2, mockTestInterfaceObject);
Assert.AreNotSame(mockedTestService.TestInterface3, mockTestInterfaceObject);
Assert.AreNotSame(mockedTestService.TestInterface2, mockedTestService.TestInterface3);
}
public void Parent()
{
JArray v = new JArray(new JConstructor("TestConstructor"), new JValue(new DateTime(2000, 12, 20)));
Assert.AreEqual(null, v.Parent);
JObject o =
new JObject(
new JProperty("Test1", v),
new JProperty("Test2", "Test2Value"),
new JProperty("Test3", "Test3Value"),
new JProperty("Test4", null)
);
Assert.AreEqual(o.Property("Test1"), v.Parent);
JProperty p = new JProperty("NewProperty", v);
// existing value should still have same parent
Assert.AreEqual(o.Property("Test1"), v.Parent);
// new value should be cloned
Assert.AreNotSame(p.Value, v);
Assert.AreEqual((DateTime)((JValue)p.Value[1]).Value, (DateTime)((JValue)v[1]).Value);
Assert.AreEqual(v, o["Test1"]);
Assert.AreEqual(null, o.Parent);
JProperty o1 = new JProperty("O1", o);
Assert.AreEqual(o, o1.Value);
Assert.AreNotEqual(null, o.Parent);
JProperty o2 = new JProperty("O2", o);
Assert.AreNotSame(o1.Value, o2.Value);
Assert.AreEqual(o1.Value.Children().Count(), o2.Value.Children().Count());
Assert.AreEqual(false, JToken.DeepEquals(o1, o2));
Assert.AreEqual(true, JToken.DeepEquals(o1.Value, o2.Value));
}
public void SingleThread_Sync_InnerUowsWithTransactionCreation_3()
{
IPersistenceUnitOfWork uow = null, innerUow = null, grandInnerUow = null;
try
{
using (uow = Subject.CreateWithTransaction(IsolationLevel.ReadCommitted))
{
using (innerUow = Subject.Create())
{
using (grandInnerUow = Subject.CreateWithTransaction(IsolationLevel.RepeatableRead))
{
ThrowsException();
}
innerUow.Complete();
}
uow.Complete();
}
}
catch (ApplicationException)
{
// exception handled
}
// assert
IPersistenceContext context = uow.Context;
IPersistenceContext childContext = innerUow.Context;
IPersistenceContext grandChildContext = grandInnerUow.Context;
Assert.AreNotSame(uow, innerUow);
Assert.AreNotSame(uow, grandInnerUow);
Assert.AreNotSame(innerUow, grandInnerUow);
Assert.AreSame(context, childContext);
Assert.AreNotSame(context, grandChildContext);
(context as IPersistenceContextExplicit).Received(0).Flush();
Assert.IsFalse(context.IsInActiveTransaction);
(grandChildContext as IPersistenceContextExplicit).Received(0).Flush();
Assert.IsFalse(grandChildContext.IsInActiveTransaction);
}
public async Task When_IsItsOwnItemContainer_FromSource_With_DataTemplate()
{
var SUT = new ListView()
{
ItemContainerStyle = BasicContainerStyle,
ItemTemplate = TextBlockItemTemplate,
SelectionMode = ListViewSelectionMode.Single,
};
WindowHelper.WindowContent = SUT;
await WindowHelper.WaitForIdle();
var source = new object[] {
new ListViewItem()
{
Content = "item 1"
},
"item 2"
};
SUT.ItemsSource = source;
SelectorItem si = null;
await WindowHelper.WaitFor(() => (si = SUT.ContainerFromItem(source[0]) as SelectorItem) != null);
Assert.AreEqual("item 1", si.Content);
Assert.AreSame(si, source[0]);
#if !NETFX_CORE
Assert.IsFalse(si.IsGeneratedContainer);
#endif
var si2 = SUT.ContainerFromItem(source[1]) as ListViewItem;
Assert.IsNotNull(si2);
Assert.AreNotSame(si2, source[1]);
Assert.AreEqual("item 2", si2.Content);
#if !NETFX_CORE
Assert.AreEqual("item 2", si2.DataContext);
Assert.IsTrue(si2.IsGeneratedContainer);
#endif
}
public virtual void TestReplaceTaxonomy()
{
Directory input = NewDirectory();
var taxoWriter = new DirectoryTaxonomyWriter(input);
int ordA = taxoWriter.AddCategory(new FacetLabel("a"));
taxoWriter.Dispose();
Directory dir = NewDirectory();
taxoWriter = new DirectoryTaxonomyWriter(dir);
int ordB = taxoWriter.AddCategory(new FacetLabel("b"));
taxoWriter.AddCategory(new FacetLabel("c"));
taxoWriter.Commit();
long origEpoch = getEpoch(dir);
// replace the taxonomy with the input one
taxoWriter.ReplaceTaxonomy(input);
// LUCENE-4633: make sure that category "a" is not added again in any case
taxoWriter.AddTaxonomy(input, new MemoryOrdinalMap());
Assert.AreEqual(2, taxoWriter.Size, "no categories should have been added"); // root + 'a'
Assert.AreEqual(ordA, taxoWriter.AddCategory(new FacetLabel("a")), "category 'a' received new ordinal?");
// add the same category again -- it should not receive the same ordinal !
int newOrdB = taxoWriter.AddCategory(new FacetLabel("b"));
Assert.AreNotSame(ordB, newOrdB, "new ordinal cannot be the original ordinal");
Assert.AreEqual(2, newOrdB, "ordinal should have been 2 since only one category was added by replaceTaxonomy");
taxoWriter.Dispose();
long newEpoch = getEpoch(dir);
Assert.True(origEpoch < newEpoch, "index epoch should have been updated after replaceTaxonomy");
dir.Dispose();
input.Dispose();
}
public void GetHashCode_Two_Objects()
{
var first = new Expense
{
Amount = 120,
Category = new ExpenseCategory
{
Id = 0,
Name = "Category"
},
Comments = "Stuff",
Date = DateTime.Today,
Id = 0,
Method = new PaymentMethod
{
Id = 0,
Name = "Method"
}
};
var second = new Expense
{
Amount = 120,
Category = new ExpenseCategory
{
Id = 0,
Name = "Category"
},
Comments = "Stuff",
Date = DateTime.Today,
Id = 0,
Method = new PaymentMethod
{
Id = 0,
Name = "Method"
}
};
Assert.AreNotSame(first, second);
Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode());
}
public void Equals_DifferentEnumerableSize_False()
{
// Arrange
HashSet <Message> messages1 = new HashSet <Message>
{
new Message {
Id = Guid.Empty, Text = "Text"
},
new Message {
Id = Guid.Empty, Text = "Text"
},
new Message {
Id = Guid.Empty, Text = "Text"
}
};
HashSet <Message> messages2 = new HashSet <Message>
{
new Message {
Id = Guid.Empty, Text = "Text"
},
new Message {
Id = Guid.Empty, Text = "Text"
}
};
Subject subject1 = new Subject()
{
Id = Guid.Empty, Name = "Subject", Messages = messages1
};
Subject subject2 = new Subject()
{
Id = Guid.Empty, Name = "Subject", Messages = messages2
};
// Act
// Assert
Assert.IsFalse(subject1.Equals(subject2));
Assert.AreNotEqual(subject1, subject2);
Assert.AreNotSame(subject1, subject2);
}
public void Can_Deep_Clone()
{
var item = new DictionaryTranslation(new Language("en-AU")
{
CreateDate = DateTime.Now,
CultureName = "en",
Id = 11,
IsoCode = "AU",
Key = Guid.NewGuid(),
UpdateDate = DateTime.Now
}, "colour")
{
CreateDate = DateTime.Now,
Id = 88,
Key = Guid.NewGuid(),
UpdateDate = DateTime.Now
};
var clone = (DictionaryTranslation)item.DeepClone();
Assert.AreNotSame(clone, item);
Assert.AreEqual(clone, item);
Assert.AreEqual(clone.CreateDate, item.CreateDate);
Assert.AreEqual(clone.Id, item.Id);
Assert.AreEqual(clone.Key, item.Key);
Assert.AreEqual(clone.UpdateDate, item.UpdateDate);
Assert.AreNotSame(clone.Language, item.Language);
//This is null because we are ignoring it from cloning due to caching/cloning issues - we don't really want
// this entity attached to this item but we're stuck with it for now
Assert.IsNull(clone.Language);
Assert.AreEqual(clone.LanguageId, item.LanguageId);
Assert.AreEqual(clone.Value, item.Value);
//This double verifies by reflection
var allProps = clone.GetType().GetProperties();
foreach (var propertyInfo in allProps.Where(x => x.Name != "Language"))
{
Assert.AreEqual(propertyInfo.GetValue(clone, null), propertyInfo.GetValue(item, null));
}
}
public void TestSetThenGetObjectOnSerializedReceivedMessageReturnsSnapshot()
{
Map origMap = new Map
{
{ "key1", "value1" }
};
global::Amqp.Message message = new global::Amqp.Message {
BodySection = new AmqpValue {
Value = origMap
}
};
AmqpNmsObjectMessageFacade facade = CreateReceivedObjectMessageFacade(message);
// verify we get a different-but-equal object back
object body = facade.Body;
Assert.IsInstanceOf <Map>(body);
Map returnedObject1 = (Map)body;
Assert.AreNotSame(origMap, returnedObject1, "Expected different objects, due to snapshot being taken");
Assert.AreEqual(origMap, returnedObject1, "Expected equal objects, due to snapshot being taken");
// verify we get a different-but-equal object back when compared to the previously retrieved object
object body2 = facade.Body;
Assert.IsInstanceOf <Map>(body2);
Map returnedObject2 = (Map)body2;
Assert.AreNotSame(origMap, returnedObject2, "Expected different objects, due to snapshot being taken");
Assert.AreEqual(returnedObject1, returnedObject2);
// mutate the original object
origMap.Add("key2", "value2");
// verify the mutated map is a different and not equal object
Assert.AreNotSame(returnedObject1, returnedObject2, "Expected different objects, due to snapshot being taken");
Assert.AreNotEqual(origMap, returnedObject2, "Expected objects to differ, due to snapshot being taken");
}
public void TestLoadClassDefs_KeyDefinedWithInheritedProperties()
{
//-------------Setup Test Pack ------------------
const string xml =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<property name=""TestClassName"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
<class name=""TestClassInherited"" assembly=""Habanero.Test.BO.Loaders"" >
<superClass class=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" />
<key>
<prop name=""TestClassName""/>
</key>
</class>
</classes>
" ;
var loader = new XmlClassDefsLoader("", new DtdLoader(), GetDefClassFactory());
var classDefList = loader.LoadClassDefs(xml);
var validator = new ClassDefValidator(GetDefClassFactory());
//--------------------Assert Preconditions-----------------
var classDefTestClass = classDefList["Habanero.Test.BO.Loaders", "TestClass"];
var propDef = classDefTestClass.PropDefcol["TestClassName"];
var classDefInherited = classDefList["Habanero.Test.BO.Loaders", "TestClassInherited"];
var keyDef = classDefInherited.KeysCol.GetKeyDefAtIndex(0);
var keyDefPropDef = keyDef["TestClassName"];
Assert.AreNotSame(propDef, keyDefPropDef,
"The key's property should have been resolved to be the property of the superclass by the validator.");
//-------------Execute test ---------------------
validator.ValidateClassDefs(classDefList);
//-------------Test Result ----------------------
var keyDefPropDefAfterValidate = keyDef["TestClassName"];
Assert.AreSame(propDef, keyDefPropDefAfterValidate,
"The key's property should have been resolved to be the property of the superclass by the loader.");
}
public void HashCodeEqualsByContent()
{
var lookup = new VariableLookup();
lookup.Resolve("a");
lookup.Resolve("b");
lookup.Resolve("c");
lookup.Resolve("x");
var variables = CreateVariables3();
State a = CreateVariables1().ToState(lookup);
State b = CreateVariables2().ToState(lookup);
State x = variables.ToState(lookup);
State y = variables.ToState(lookup);
State z = CreateVariables3().ToState(lookup);
// self equality
Assert.AreNotSame(x, y);
Assert.AreNotSame(x, z);
Assert.AreNotSame(y, z);
Assert.AreEqual(x.GetHashCode(), x.GetHashCode());
Assert.AreEqual(y.GetHashCode(), y.GetHashCode());
Assert.AreEqual(z.GetHashCode(), z.GetHashCode());
// hash equality by content
Assert.AreEqual(x.GetHashCode(), y.GetHashCode());
Assert.AreEqual(y.GetHashCode(), x.GetHashCode());
Assert.AreEqual(x.GetHashCode(), z.GetHashCode());
Assert.AreEqual(z.GetHashCode(), x.GetHashCode());
Assert.AreEqual(y.GetHashCode(), z.GetHashCode());
Assert.AreEqual(z.GetHashCode(), y.GetHashCode());
// more hash equality by content
Assert.AreNotSame(x, a);
Assert.AreNotSame(x, b);
Assert.AreNotEqual(x.GetHashCode(), a.GetHashCode());
Assert.AreNotEqual(a.GetHashCode(), x.GetHashCode());
Assert.AreNotEqual(x.GetHashCode(), b.GetHashCode());
Assert.AreNotEqual(b.GetHashCode(), x.GetHashCode());
}
public void EqualsByContent()
{
var lookup = new VariableLookup();
lookup.Resolve("a");
lookup.Resolve("b");
lookup.Resolve("c");
lookup.Resolve("x");
var variables = CreateVariables3();
State a = CreateVariables1().ToState(lookup);
State b = CreateVariables2().ToState(lookup);
State x = variables.ToState(lookup);
State y = variables.ToState(lookup);
State z = CreateVariables3().ToState(lookup);
// self equality
Assert.AreNotSame(x, y);
Assert.AreNotSame(x, z);
Assert.AreNotSame(y, z);
Assert.AreEqual(x, x);
Assert.AreEqual(y, y);
Assert.AreEqual(z, z);
// equality by content
Assert.AreEqual(x, y);
Assert.AreEqual(y, x);
Assert.AreEqual(x, z);
Assert.AreEqual(z, x);
Assert.AreEqual(y, z);
Assert.AreEqual(z, y);
// more equality by content
Assert.AreNotSame(x, a);
Assert.AreNotSame(x, b);
Assert.AreNotEqual(x, a);
Assert.AreNotEqual(a, x);
Assert.AreNotEqual(x, b);
Assert.AreNotEqual(b, x);
}
