Exemple #1
0
 public NodeStartupScenario(ITestOutputHelper output, TestableGateway testableGateway)
 {
     _testableGateway = testableGateway;
     _dbCtx           = testableGateway.DbCtx;
     _msgChannel      = new Mock <INodeMessageChannel>();
     _gtw             = testableGateway.CreateGateway(_msgChannel.Object);
     Logger.Debug("Gateway created with channel {0}", _msgChannel.GetHashCode());
 }
        public void ShouldCreate()
        {
            var httpClientMock = new Mock <IReloadlyHttpClient>().Object;
            var baseUri        = ServiceUrls.AirtimeAuth;
            var operation      = new BaseOperationImpl(httpClientMock, new Uri(baseUri), Enums.ReloadlyEnvironment.Sandbox);

            Assert.AreEqual(httpClientMock.GetHashCode(), operation.HttpClient.GetHashCode());
            Assert.AreEqual(new Uri(baseUri), operation.BaseUri);
            Assert.AreEqual(Enums.ReloadlyEnvironment.Sandbox, operation.Environment);
        }
        public void add_card_to_top_of_deck()
        {
            int          N       = 48;
            IDeck        d       = GetDeckOfMockCards(N);
            Mock <ICard> newCard = new Mock <ICard>();

            d.AddCardToTop(newCard.Object);
            ICard topCard = d.DealTopCard();

            Assert.AreEqual(newCard.GetHashCode(), topCard.GetHashCode());
        }
        public void add_card_to_end_of_deck()
        {
            int          N       = 48;
            IDeck        d       = GetDeckOfMockCards(N);
            Mock <ICard> newCard = new Mock <ICard>();

            d.AddCardToEnd(newCard.Object);
            ICard lastCard = d.DealBottomCard();

            Assert.AreEqual(newCard.GetHashCode(), lastCard.GetHashCode());
        }
Exemple #5
0
        public void RegisterServiceExtensionTest()
        {
            var mockService = new Mock <IServiceCollection>();

            mockService.Setup(z => z.Count).Returns(666);

            mockService.Object.AddSenparcGlobalServices();

            Assert.IsNotNull(RegisterService.GlobalServiceCollection);
            Assert.AreEqual(mockService.GetHashCode(), RegisterService.GlobalServiceCollection.GetHashCode());
            Assert.AreEqual(666, RegisterService.GlobalServiceCollection.Count);
        }
        public void insert_card_at_a_specific_position()
        {
            int          N = 52;
            int          positionToInsert = 5;
            Deck         d       = (Deck)GetDeckOfMockCards(N);
            Mock <ICard> newCard = new Mock <ICard>();

            d.InsertCard(newCard.Object, positionToInsert);
            ICard insertedCard = d.DealCard(positionToInsert);

            Assert.AreEqual(newCard.GetHashCode(), insertedCard.GetHashCode());
        }
Exemple #7
0
        public void GetHashcode_EqualObjects_ReturnsEqualHashCodes()
        {
            var song1 = new Mock <Song>("TestPath", AudioType.Mp3, TimeSpan.Zero)
            {
                CallBase = true
            }.Object;
            var song2 = new Mock <Song>("TestPath", AudioType.Mp3, TimeSpan.Zero)
            {
                CallBase = true
            }.Object;

            Assert.AreEqual(song1.GetHashCode(), song2.GetHashCode());
        }
        private static Type CreateDynamicType(DynamicType dynamicType)
        {
            Mock <Type> type = new Mock <Type>();

            type.Setup(t => t.Name).Returns(dynamicType.TypeName);
            type.Setup(t => t.Namespace).Returns("SampleNamespace");
            type.Setup(t => t.FullName).Returns("SampleNamespace." + dynamicType.TypeName);
            type
            .Setup(t => t.GetProperties(It.IsAny <BindingFlags>()))
            .Returns(dynamicType.Properties.Select(property => CreateProperty(property, type.Object)).Cast <PropertyInfo>().ToArray());
            type.Setup(t => t.IsAssignableFrom(type.Object)).Returns(true);
            type.Setup(t => t.GetHashCode()).Returns(type.GetHashCode());
            type.Setup(t => t.Equals(It.IsAny <object>())).Returns((Type t) => Object.ReferenceEquals(type.Object, t));
            return(type.Object);
        }
Exemple #9
0
        private static IProxyDataset CreateMockDataset()
        {
            var dataset = new Mock <IProxyDataset>();

            {
                dataset.Setup(d => d.Equals(It.IsAny <IProxyDataset>()))
                .Returns <IProxyDataset>(other => ReferenceEquals(other, dataset.Object));

                dataset.Setup(d => d.Equals(It.IsAny <object>()))
                .Returns <object>(other => ReferenceEquals(other, dataset.Object));

                dataset.Setup(d => d.GetHashCode())
                .Returns(dataset.GetHashCode());
            }

            return(dataset.Object);
        }
        public void GetHashCode_Invoke_ReturnsIdGetHashCode()
        {
            // Arrange
            var expectedHashCode = 12345;
            var idStub           = Mock.Of <object>(s => s.GetHashCode() == expectedHashCode);
            var subject          = new Mock <EntityBase <object> >
            {
                CallBase = true
            }
            .SetupProperty(s => s.Id, idStub)
            .Object;

            // Act
            var hashCode = subject.GetHashCode();

            // Assert
            hashCode.Should().Be(expectedHashCode);
        }
        private static Mock <IProxyDataset> CreateDataset(int index, IEnumerable <Mock <IProxyDataset> > children)
        {
            var proxy = new Mock <IProxyDataset>();

            {
                proxy.Setup(p => p.Name)
                .Returns(index.ToString(CultureInfo.InvariantCulture));
                proxy.Setup(p => p.Children())
                .Returns(children.Select(c => c.Object));
                proxy.Setup(p => p.Id)
                .Returns(new DatasetId(index));
                proxy.Setup(d => d.Equals(It.IsAny <IProxyDataset>()))
                .Returns <IProxyDataset>(other => ReferenceEquals(other, proxy.Object));
                proxy.Setup(d => d.Equals(It.IsAny <object>()))
                .Returns <object>(other => ReferenceEquals(other, proxy.Object));
                proxy.Setup(d => d.GetHashCode())
                .Returns(proxy.GetHashCode());
            }

            return(proxy);
        }
        private static PropertyInfo CreateProperty(DynamicProperty property, Type reflectedType)
        {
            Mock <PropertyInfo> pi = new Mock <PropertyInfo>();

            pi.Setup(p => p.Name).Returns(property.Name);

            if (property.Type is DynamicType)
            {
                property.Type = CreateDynamicType(property.Type as DynamicType);
            }

            pi.Setup(p => p.PropertyType).Returns(property.Type as Type);
            pi.Setup(p => p.ReflectedType).Returns(reflectedType);
            pi.Setup(p => p.DeclaringType).Returns(reflectedType);
            pi.Setup(p => p.CanRead).Returns(true);
            pi.Setup(p => p.CanWrite).Returns(true);
            pi.Setup(p => p.GetGetMethod(It.IsAny <bool>())).Returns(typeof(Product).GetProperty("ID").GetGetMethod());
            pi.Setup(p => p.GetCustomAttributes(It.IsAny <bool>())).Returns(property.Attributes);
            pi.Setup(p => p.GetHashCode()).Returns(pi.GetHashCode());
            pi.Setup(p => p.Equals(It.IsAny <object>())).Returns((PropertyInfo p) => Object.ReferenceEquals(pi.Object, p));
            return(pi.Object);
        }
Exemple #13
0
 public override int GetHashCode()
 {
     return(Mock.GetHashCode() ^ Method.GetHashCode());
 }
        private void MockHashTest(Mock <IParentInterface> mock)
        {
            int i = mock.GetHashCode();

            Assert.AreEqual(33650554, i);
        }
        private static PropertyInfo CreateProperty(DynamicProperty property, Type reflectedType)
        {
            Mock<PropertyInfo> pi = new Mock<PropertyInfo>();
            pi.Setup(p => p.Name).Returns(property.Name);

            if (property.Type is DynamicType)
            {
                property.Type = CreateDynamicType(property.Type as DynamicType);
            }

            pi.Setup(p => p.PropertyType).Returns(property.Type as Type);
            pi.Setup(p => p.ReflectedType).Returns(reflectedType);
            pi.Setup(p => p.DeclaringType).Returns(reflectedType);
            pi.Setup(p => p.CanRead).Returns(true);
            pi.Setup(p => p.CanWrite).Returns(true);
            pi.Setup(p => p.GetGetMethod(It.IsAny<bool>())).Returns(typeof(Product).GetProperty("ID").GetGetMethod());
            pi.Setup(p => p.GetCustomAttributes(It.IsAny<bool>())).Returns(property.Attributes);
            pi.Setup(p => p.GetHashCode()).Returns(pi.GetHashCode());
            pi.Setup(p => p.Equals(It.IsAny<object>())).Returns((PropertyInfo p) => Object.ReferenceEquals(pi.Object, p));
            return pi.Object;
        }
 private static Type CreateDynamicType(DynamicType dynamicType)
 {
     Mock<Type> type = new Mock<Type>();
     type.Setup(t => t.Name).Returns(dynamicType.TypeName);
     type.Setup(t => t.Namespace).Returns("SampleNamespace");
     type.Setup(t => t.FullName).Returns("SampleNamespace." + dynamicType.TypeName);
     type
         .Setup(t => t.GetProperties(It.IsAny<BindingFlags>()))
         .Returns(dynamicType.Properties.Select(property => CreateProperty(property, type.Object)).Cast<PropertyInfo>().ToArray());
     type.Setup(t => t.IsAssignableFrom(type.Object)).Returns(true);
     type.Setup(t => t.GetHashCode()).Returns(type.GetHashCode());
     type.Setup(t => t.Equals(It.IsAny<object>())).Returns((Type t) => Object.ReferenceEquals(type.Object, t));
     return type.Object;
 }
 /// <summary>
 /// Serves as a hash function for a particular type.
 /// </summary>
 /// <returns>
 /// A hash code for the current <see cref="T:System.Object"/>.
 /// </returns>
 public override int GetHashCode()
 {
     return(Mock.GetHashCode() ^ NestedMockType.GetHashCode());
 }
        private static Mock<IProxyDataset> CreateDataset(int index, IEnumerable<Mock<IProxyDataset>> children)
        {
            var proxy = new Mock<IProxyDataset>();
            {
                proxy.Setup(p => p.Name)
                    .Returns(index.ToString(CultureInfo.InvariantCulture));
                proxy.Setup(p => p.Children())
                    .Returns(children.Select(c => c.Object));
                proxy.Setup(p => p.Id)
                    .Returns(new DatasetId(index));
                proxy.Setup(d => d.Equals(It.IsAny<IProxyDataset>()))
                    .Returns<IProxyDataset>(other => ReferenceEquals(other, proxy.Object));
                proxy.Setup(d => d.Equals(It.IsAny<object>()))
                    .Returns<object>(other => ReferenceEquals(other, proxy.Object));
                proxy.Setup(d => d.GetHashCode())
                    .Returns(proxy.GetHashCode());
            }

            return proxy;
        }
        private static IProxyDataset CreateMockDataset()
        {
            var dataset = new Mock<IProxyDataset>();
            {
                dataset.Setup(d => d.Equals(It.IsAny<IProxyDataset>()))
                    .Returns<IProxyDataset>(other => ReferenceEquals(other, dataset.Object));

                dataset.Setup(d => d.Equals(It.IsAny<object>()))
                    .Returns<object>(other => ReferenceEquals(other, dataset.Object));

                dataset.Setup(d => d.GetHashCode())
                    .Returns(dataset.GetHashCode());
            }

            return dataset.Object;
        }