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); }