Exemple #1
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));
        }
Exemple #2
0
            public void It_should_return_object_GetHashCode_for_non_null_values()
            {
                var instance         = new MyClass(Guid.NewGuid().ToString("D", CultureInfo.InvariantCulture));
                var instanceHashCode = instance.GetHashCode();

                var actual = target.GetHashCode(instance);

                actual.Should().Be(instanceHashCode);
            }
Exemple #3
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 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());
        }
Exemple #6
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 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()));
                }
Exemple #8
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 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 );
		}
Exemple #10
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"));
 }
Exemple #11
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());
        }
Exemple #12
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);
        }
Exemple #14
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 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));
        }
Exemple #16
0
 public void GetHashcode()
 {
     Assert.That(_comparer.GetHashCode(_obj1), Is.EqualTo(_comparer.GetHashCode(_obj1)));
 }
Exemple #17
0
 public void generic_iEqualityComparer_getHashCode_null_reference()
 {
     IEqualityComparer <GenericParameterHelper> instance = new ReferenceEqualityComparer <GenericParameterHelper>();
     int actual = instance.GetHashCode(null);
 }
 int IEqualityComparer <object> .GetHashCode(object a)
 {
     return(ReferenceEqualityComparer.GetHashCode(a));
 }
Exemple #19
0
            public void It_should_return_zero()
            {
                var actual = target.GetHashCode(null);

                actual.Should().Be(0);
            }
		public void generic_iEqualityComparer_getHashCode_null_reference()
		{
			IEqualityComparer<GenericParameterHelper> instance = new ReferenceEqualityComparer<GenericParameterHelper>();
			Int32 actual = instance.GetHashCode( null );
		}
Exemple #21
0
 public sealed override int GetHashCode()
 {
     return(ReferenceEqualityComparer.GetHashCode(this));
 }