public static UnrootedSymbolSet GetUnrootedSymbols(Compilation compilation)
                {
                    var primaryAssembly = new WeakReference <IAssemblySymbol>(compilation.Assembly);

                    // The dynamic type is also unrooted (i.e. doesn't point back at the compilation or source
                    // assembly).  So we have to keep track of it so we can get back from it to a project in case the
                    // underlying compilation is GC'ed.
                    var primaryDynamic = new WeakReference <ITypeSymbol?>(
                        compilation.Language == LanguageNames.CSharp ? compilation.DynamicType : null);

                    // PERF: Preallocate this array so we don't have to resize it as we're adding assembly symbols.
                    using var _ = ArrayBuilder <(int hashcode, WeakReference <ISymbol> symbol)> .GetInstance(
                              compilation.ExternalReferences.Length + compilation.DirectiveReferences.Length, out var secondarySymbols);

                    foreach (var reference in compilation.References)
                    {
                        var symbol = compilation.GetAssemblyOrModuleSymbol(reference);
                        if (symbol == null)
                        {
                            continue;
                        }

                        secondarySymbols.Add((ReferenceEqualityComparer.GetHashCode(symbol), new WeakReference <ISymbol>(symbol)));
                    }

                    // Sort all the secondary symbols by their hash.  This will allow us to easily binary search for
                    // them afterwards. Note: it is fine for multiple symbols to have the same reference hash.  The
                    // search algorithm will account for that.
                    secondarySymbols.Sort(WeakSymbolComparer.Instance);
                    return(new UnrootedSymbolSet(primaryAssembly, primaryDynamic, secondarySymbols.ToImmutable()));
                }
Exemplo n.º 2
0
        public void generic_iEqualityComparer_equals_with_null_and_null()
        {
            var  instance = new ReferenceEqualityComparer <GenericParameterHelper>();
            bool actual   = instance.Equals(null, null);

            actual.Should().Be.True();
        }
		public void generic_iEqualityComparer_equals_with_null_and_null()
		{
			var instance = new ReferenceEqualityComparer<GenericParameterHelper>();
			bool actual = instance.Equals( null, null );

			actual.Should().Be.True();
		}
Exemplo n.º 4
0
        public void ReferenceEqualityComparerShouldNotUseOverriddenHash()
        {
            var t = new OverriddenHash();
            var equalityComparer = new ReferenceEqualityComparer();

            Assert.AreNotEqual(42, equalityComparer.GetHashCode(t));
            Assert.AreEqual(equalityComparer.GetHashCode(t), RuntimeHelpers.GetHashCode(t));
        }
Exemplo n.º 5
0
        public void ReferenceEqualityComparerClassEqualsMethodReturnsTrueWhenTheSameTimeOfDayObjectIsPassedToBothParameters()
        {
            TimeOfDay testParam = _rnd.NextTimeOfDay();
            ReferenceEqualityComparer testObject = ReferenceEqualityComparer.Default;

            bool testOutput = testObject.Equals(testParam, testParam);

            Assert.IsTrue(testOutput);
        }
Exemplo n.º 6
0
        internal static bool IsItemContainedInAllSourceItems <TItemSource>(
            IViewModel selectionVM,
            TItemSource sourceItem
            )
        {
            IEnumerable <TItemSource> allSourceItems = GetAllSourceItems <TItemSource>(selectionVM);

            return(allSourceItems.Contains(sourceItem, ReferenceEqualityComparer <TItemSource> .CreateSmartComparer()));
        }
Exemplo n.º 7
0
        public void iEqualityComparer_equals_with_null_and_instance()
        {
            IEqualityComparer instance = new ReferenceEqualityComparer <GenericParameterHelper>();

            var  y      = new GenericParameterHelper();
            bool actual = instance.Equals(null, y);

            actual.Should().Be.False();
        }
Exemplo n.º 8
0
        public NameFixupGraph()
        {
            ReferenceEqualityComparer <object> singleton = ReferenceEqualityComparer <object> .Singleton;

            this._dependenciesByChildObject       = new Dictionary <object, NameFixupToken>(singleton);
            this._dependenciesByName              = new Dictionary <string, FrugalObjectList <NameFixupToken> >(StringComparer.Ordinal);
            this._dependenciesByParentObject      = new Dictionary <object, FrugalObjectList <NameFixupToken> >(singleton);
            this._resolvedTokensPendingProcessing = new Queue <NameFixupToken>();
            this._uninitializedObjectsAtParseEnd  = new System.Xaml.Context.HashSet <object>(singleton);
        }
Exemplo n.º 9
0
        public void Equals_SameInstance_ReturnTrue()
        {
            // Setup
            var comparer = new ReferenceEqualityComparer <object>();
            var obj      = new object();

            // Call & Assert
            Assert.IsTrue(comparer.Equals(obj, obj));
            Assert.AreEqual(comparer.GetHashCode(obj), comparer.GetHashCode(obj));
        }
        public void InstanceProperty_ReturnsSingleton()
        {
            ReferenceEqualityComparer comparer1 = ReferenceEqualityComparer.Instance;

            Assert.NotNull(comparer1);

            ReferenceEqualityComparer comparer2 = ReferenceEqualityComparer.Instance;

            Assert.Same(comparer1, comparer2);
        }
Exemplo n.º 11
0
        public void iEqualityComparer_getHashCode()
        {
            IEqualityComparer instance = new ReferenceEqualityComparer <GenericParameterHelper>();
            var obj = new GenericParameterHelper();

            int expected = obj.GetHashCode();
            int actual   = instance.GetHashCode(obj);

            actual.Should().Be.EqualTo(expected);
        }
        public void TwoClassInstances_AreNotEquals()
        {
            var rec = new ReferenceEqualityComparer();
            var instance = new Entity();
            rec.Equals(instance, new Entity()).Should().Be.False();
            rec.Equals(instance, instance).Should().Be.True();

            rec.GetHashCode().Should().Not.Be.EqualTo(17);
            rec.GetHashCode().Should().Not.Be.EqualTo((new Entity()).GetHashCode());
        }
        public void TwoClassInstances_AreNotEquals()
        {
            var rec      = new ReferenceEqualityComparer();
            var instance = new Entity();

            rec.Equals(instance, new Entity()).Should().Be.False();
            rec.Equals(instance, instance).Should().Be.True();

            rec.GetHashCode().Should().Not.Be.EqualTo(17);
            rec.GetHashCode().Should().Not.Be.EqualTo((new Entity()).GetHashCode());
        }
Exemplo n.º 14
0
        public void iEqualityComparer_equals_with_equal_instances()
        {
            IEqualityComparer instance = new ReferenceEqualityComparer <GenericParameterHelper>();

            var x = new GenericParameterHelper();
            var y = x;

            bool actual = instance.Equals(x, y);

            actual.Should().Be.True();
        }
		public void generic_iEqualityComparer_equals_with_equal_instances()
		{
			var instance = new ReferenceEqualityComparer<GenericParameterHelper>();

			var x = new GenericParameterHelper();
			var y = x;

			bool actual = instance.Equals( x, y );

			actual.Should().Be.True();
		}
        public void AnObjectIsEqualToItself()
        {
            var referenceComparer = new ReferenceEqualityComparer();

            var obj1 = new object();
            var obj2 = obj1;

            var consideredEqual = referenceComparer.Equals(obj1, obj2);

            Assert.IsTrue(consideredEqual);
        }
        public WrapperCollectionAccessorBehavior(
            bool shouldCacheSourceCollection,
            IEqualityComparer <TItemSource> reusabilitySourceComparer = null
            )
        {
            _shouldCacheSourceCollection = shouldCacheSourceCollection;

            _reusabilitySourceComparer =
                reusabilitySourceComparer ??
                ReferenceEqualityComparer <TItemSource> .CreateSmartComparer();
        }
		public void generic_iEqualityComparer_getHashCode()
		{
			IEqualityComparer<GenericParameterHelper> instance = new ReferenceEqualityComparer<GenericParameterHelper>();

			var obj = new GenericParameterHelper();
			Int32 expected = obj.GetHashCode();

			Int32 actual = instance.GetHashCode( obj );

			actual.Should().Be.EqualTo( expected );
		}
Exemplo n.º 19
0
 public void NullSafe()
 {
     var req = new ReferenceEqualityComparer<string>();
     Assert.AreEqual(0, req.GetHashCode(null));
     Assert.True(req.Equals(null, null));
     Assert.False(req.Equals(null, "abc"));
     var reqo = new ReferenceEqualityComparer();
     Assert.AreEqual(0, reqo.GetHashCode(null));
     Assert.True(reqo.Equals(null, null));
     Assert.False(reqo.Equals(null, "abc"));
 }
        public static void Equals___Should_return_true___When_both_objects_are_the_same_reference()
        {
            // Arrange
            var item            = Some.Dummies <byte>().ToArray();
            var systemUnderTest = new ReferenceEqualityComparer <byte[]>();

            // Act
            var actual = systemUnderTest.Equals(item, item);

            // Assert
            actual.Should().BeTrue();
        }
Exemplo n.º 21
0
        /// <summary>
        /// Constructs a caching reference resolver.
        /// </summary>
        /// <param name="maxAge">The time a reference should be cached.</param>
        /// <param name="maxCapacity">The maximum number of references to cache. If the limit is reached, the oldest references are evicted.</param>
        /// <param name="equalityComparer">An equality comparer to be used to determine equality of referenced objects.</param>
        public CachingReferenceResolver(TimeSpan maxAge, int maxCapacity, IEqualityComparer <object> equalityComparer)
        {
            if (equalityComparer == null)
            {
                equalityComparer = new ReferenceEqualityComparer();
            }

            this.references    = new Dictionary <object, string>(equalityComparer);
            this.evictionQueue = new Queue <CacheItem>();
            this.maxCapacity   = maxCapacity;
            this.maxAge        = maxAge;
        }
Exemplo n.º 22
0
        public void HashCode_Object_ReturnHashCode()
        {
            // Setup
            var comparer = new ReferenceEqualityComparer <object>();
            var obj      = new object();

            // Call
            int code = comparer.GetHashCode(obj);

            // Assert
            Assert.AreEqual(code, obj.GetHashCode());
        }
Exemplo n.º 23
0
        public void ReferenceEqualityComparerClassEqualsMethodReturnsFalseWhenTwoDifferentButEqualTimeOfDayObjectsArePassedAsParameters()
        {
            TimeOfDay testParam0 = _rnd.NextTimeOfDay();
            TimeOfDay testParam1 = new TimeOfDay(testParam0.AbsoluteSeconds);
            ReferenceEqualityComparer testObject = ReferenceEqualityComparer.Default;

            bool testOutput = testObject.Equals(testParam0, testParam1);

            Assert.IsFalse(testOutput);
            // Just to double-check that the parameters do compare equal!
            Assert.AreEqual(testParam0, testParam1);
        }
Exemplo n.º 24
0
        public void HashCode_ObjectHashCodeOverride_ReturnsObjectHashCode()
        {
            // Setup
            var comparer = new ReferenceEqualityComparer <object>();
            var obj      = new TestObject();

            // Call
            int code = comparer.GetHashCode(obj);

            // Assert
            Assert.AreNotEqual(code, obj.GetHashCode());
            Assert.AreEqual(code, obj.GetBaseHashCode());
        }
        public void GetHashCodeIgnoresHashAsIEquatable()
        {
            var referenceComparer = new ReferenceEqualityComparer();

            var mock = new Mock <IEquatable <object> >();

            mock.Setup(obj => obj.GetHashCode()).Returns(0);
            var objct = mock.Object;

            var hashCode = referenceComparer.GetHashCode(objct);

            Assert.AreNotEqual(0, hashCode);
        }
        public static void Equals___Should_return_true___When_both_objects_are_null()
        {
            // Arrange
            object item1           = null;
            object item2           = null;
            var    systemUnderTest = new ReferenceEqualityComparer <object>();

            // Act
            var actual = systemUnderTest.Equals(item1, item2);

            // Assert
            actual.Should().BeTrue();
        }
        public static void Equals___Should_return_false___When_objects_are_not_the_same_reference_and_equal()
        {
            // Arrange
            var item1 = new Version(1, 2, 3, 4);
            var item2 = new Version(1, 2, 3, 4);

            var systemUnderTest = new ReferenceEqualityComparer <object>();

            // Act
            var actual = systemUnderTest.Equals(item1, item2);

            // Assert
            actual.Should().BeFalse();
        }
Exemplo n.º 28
0
        public void TestCase03_CompareNullableValueTypes()
        {
            ReferenceEqualityComparer <DateTime?> comparer = new ReferenceEqualityComparer <DateTime?>();

            /* Situation 1: Comparing two variables that point to the same instance (note: a nullable value-type is still a value-type) */
            DateTime?dummyA = new DateTime?(new DateTime(2000, 5, 10));
            DateTime?dummyB = dummyA;
            bool     result = comparer.Equals(dummyA, dummyB);

            Assert.IsFalse(result);

            /* Situation 2: Comparing two variables that point to different instances with different contents */
            dummyA = new DateTime?(new DateTime(2000, 5, 10));
            dummyB = new DateTime?(new DateTime(2000, 6, 9));
            result = comparer.Equals(dummyA, dummyB);
            Assert.IsFalse(result);

            /* Situation 3: Comparing two variables that point to different instances with the same content */
            dummyA = new DateTime?(new DateTime(2000, 5, 10));
            dummyB = new DateTime?(new DateTime(2000, 5, 10));
            result = comparer.Equals(dummyA, dummyB);
            Assert.IsFalse(result);

            /* Situation 4: Comparing an instance with its 'clone' */
            DateTime testValue = new DateTime(2000, 5, 10);

            dummyA = new DateTime?(testValue);
            dummyB = new DateTime?(testValue);
            result = comparer.Equals(dummyA, dummyB);
            Assert.IsFalse(result);

            /* Situation 5: Comparing an instance with a null-value */
            dummyA = new DateTime?(new DateTime(2000, 5, 10));
            dummyB = null;
            result = comparer.Equals(dummyA, dummyB);
            Assert.IsFalse(result);

            /* Situation 6: Comparing a null-value with an instance */
            dummyA = null;
            dummyB = new DateTime?(new DateTime(2000, 5, 10));
            result = comparer.Equals(dummyA, dummyB);
            Assert.IsFalse(result);

            /* Situation 6: Comparing two null-values */
            dummyA = null;
            dummyB = null;
            result = comparer.Equals(dummyA, dummyB);
            Assert.IsTrue(result);
        }
Exemplo n.º 29
0
        public void Equals_OtherEqualsInstance_ReturnFalse()
        {
            // Setup
            var comparer     = new ReferenceEqualityComparer <object>();
            var objectFirst  = new TestObject();
            var objectSecond = new TestObject();

            // Call
            bool equals = comparer.Equals(objectFirst, objectSecond);

            // Assert
            Assert.IsFalse(equals);
            Assert.IsTrue(objectFirst.Equals(objectSecond));
            Assert.AreNotEqual(comparer.GetHashCode(objectFirst), comparer.GetHashCode(objectSecond));
        }
        public void GetHashCode_UsesRuntimeHelpers()
        {
            ClassWithBadGetHashCodeImplementation o = new ClassWithBadGetHashCodeImplementation(); // make sure we don't call object.GetHashCode()

            ReferenceEqualityComparer  comparer1 = ReferenceEqualityComparer.Instance;
            IEqualityComparer          comparer2 = ReferenceEqualityComparer.Instance;
            IEqualityComparer <object> comparer3 = ReferenceEqualityComparer.Instance;
            IEqualityComparer <ClassWithBadGetHashCodeImplementation> comparer4 = ReferenceEqualityComparer.Instance; // test contravariance

            int runtimeHelpersHashCode = RuntimeHelpers.GetHashCode(o);

            Assert.Equal(runtimeHelpersHashCode, comparer1.GetHashCode(o));
            Assert.Equal(runtimeHelpersHashCode, comparer2.GetHashCode(o));
            Assert.Equal(runtimeHelpersHashCode, comparer3.GetHashCode(o));
            Assert.Equal(runtimeHelpersHashCode, comparer4.GetHashCode(o));
        }
        public void DifferentObjectsEqualAsIEquatableAreNotConsideredEqual()
        {
            var referenceComparer = new ReferenceEqualityComparer();

            var mock1 = new Mock <IEquatable <object> >();

            mock1.Setup(obj => obj.Equals(It.IsAny <object>())).Returns(true);
            var mock2 = new Mock <IEquatable <object> >();

            mock2.Setup(obj => obj.Equals(It.IsAny <object>())).Returns(true);
            var obj1 = mock1.Object;
            var obj2 = mock2.Object;

            var consideredEqual = referenceComparer.Equals(obj1, obj2);

            Assert.IsFalse(consideredEqual);
        }
Exemplo n.º 32
0
        public void TestCase02_CompareValueTypes()
        {
            ReferenceEqualityComparer <DateTime> comparer = new ReferenceEqualityComparer <DateTime>();

            /* Situation 1: Comparing two variables that point to different instances with different contents */
            DateTime dummyA = new DateTime(2000, 5, 10);
            DateTime dummyB = new DateTime(2000, 6, 9);
            bool     result = comparer.Equals(dummyA, dummyB);

            Assert.IsFalse(result);

            /* Situation 2: Comparing two variables that point to different instances with the same content */
            dummyA = new DateTime(2000, 5, 10);
            dummyB = new DateTime(2000, 5, 10);
            result = comparer.Equals(dummyA, dummyB);
            Assert.IsFalse(result);
        }
        private Dictionary <TItemSource, TItemVM> GetCache(IBehaviorContext context)
        {
            Dictionary <TItemSource, TItemVM> cache;

            if (!context.FieldValues.TryGetValue(_cache, out cache))
            {
                // Reference equality because:
                //   (1) If the source objects are reloaded in a new NHibernate session,
                //       the are equal to the old object and thus item VMs would be mistakenly
                //       reused.
                //   (2) If two items of the all source items collection are equal, only one
                //       view model would be created for both.
                cache = new Dictionary <TItemSource, TItemVM>(ReferenceEqualityComparer <TItemSource> .CreateSmartComparer());
                context.FieldValues.SetValue(_cache, cache);
            }

            return(cache);
        }
        public static void Equals___Should_return_false___When_one_object_is_null_and_the_other_is_not_null()
        {
            // Arrange
            var     item1a = new Version();
            Version item1b = null;

            Version item2a = null;
            var     item2b = new Version();

            var systemUnderTest = new ReferenceEqualityComparer <Version>();

            // Act
            var actual1 = systemUnderTest.Equals(item1a, item1b);
            var actual2 = systemUnderTest.Equals(item2a, item2b);

            // Assert
            actual1.Should().BeFalse();
            actual2.Should().BeFalse();
        }
Exemplo n.º 35
0
        /// <summary>
        /// Clones the current data service context data
        /// </summary>
        /// <returns>A clone of the current data service context data</returns>
        public DataServiceContextData Clone()
        {
            var clone = new DataServiceContextData(this.ContextType, this.MaxProtocolVersion);
            clone.nextChangeOrder = this.nextChangeOrder;

            if (this.BaseUri != null)
            {
                clone.BaseUri = new Uri(this.BaseUri.OriginalString, UriKind.RelativeOrAbsolute);
            }
            
            clone.AddAndUpdateResponsePreference = this.AddAndUpdateResponsePreference;
            clone.MergeOption = this.MergeOption;
            clone.ResolveEntitySet = this.ResolveEntitySet;
            clone.ResolveName = this.ResolveName;
            clone.ResolveType = this.ResolveType;
            clone.UsePostTunneling = this.UsePostTunneling;
            clone.HttpStack = this.HttpStack;

            var mapping = new Dictionary<EntityDescriptorData, EntityDescriptorData>(ReferenceEqualityComparer.Create<EntityDescriptorData>());
            foreach (var entityDescriptor in this.entityDatas)
            {
                var clonedDescriptor = entityDescriptor.Clone(clone);
                mapping[entityDescriptor] = clonedDescriptor;
                clone.entityDatas.Add(clonedDescriptor);
            }

            foreach (var linkDescriptor in this.linkDatas)
            {
                EntityDescriptorData clonedSource = null;
                EntityDescriptorData clonedTarget = null;
                mapping.TryGetValue(linkDescriptor.SourceDescriptor, out clonedSource);
                if (linkDescriptor.TargetDescriptor != null)
                {
                    mapping.TryGetValue(linkDescriptor.TargetDescriptor, out clonedTarget);
                }

                var clonedDescriptor = linkDescriptor.Clone(clonedSource, clonedTarget);
                clone.linkDatas.Add(clonedDescriptor);
            }

            return clone;
        }
Exemplo n.º 36
0
 public void IgnoresEquivalence()
 {
     string x = new string(new []{ 'a', 'b', 'c', 'd' });
     string y = new string(new []{ 'a', 'b', 'c', 'd' });
     if(!Equals(x, y))
         Assert.Inconclusive("Compiler has optimised x and y to one object. Change test!");
     var req = new ReferenceEqualityComparer<string>();
     Assert.False(req.Equals(x, y));
     Assert.True(req.Equals(x, x));
     var reqo = new ReferenceEqualityComparer();
     Assert.False(reqo.Equals(x, y));
     Assert.True(reqo.Equals(x, x));
     if(req.GetHashCode(x) == req.GetHashCode(y))
         Assert.Inconclusive
             ("Same hashcode could happen rarely, but if more than once in a blue moon, this is a bug");
     if(reqo.GetHashCode(x) == req.GetHashCode(y))
         Assert.Inconclusive
             ("Same hashcode could happen rarely, but if more than once in a blue moon, this is a bug");
     if(req.GetHashCode(x) == x.GetHashCode())
         Assert.Inconclusive
         ("Same hashcode could happen rarely, but if more than once in a blue moon, this is a bug");
     Assert.AreEqual(reqo.GetHashCode(x), req.GetHashCode(x));
 }
		public void iEqualityComparer_equals_with_null_and_instance()
		{
			IEqualityComparer instance = new ReferenceEqualityComparer<GenericParameterHelper>();

			var y = new GenericParameterHelper();
			bool actual = instance.Equals( null, y );

			actual.Should().Be.False();
		}
		public void referenceEqualityComparer_ctor()
		{
			ReferenceEqualityComparer<GenericParameterHelper> instance = new ReferenceEqualityComparer<GenericParameterHelper>();
		}
		public void generic_iEqualityComparer_getHashCode_null_reference()
		{
			IEqualityComparer<GenericParameterHelper> instance = new ReferenceEqualityComparer<GenericParameterHelper>();
			Int32 actual = instance.GetHashCode( null );
		}