public void GetTypes_ForInterfaceOnValueType_ReturnsInterfaceAndImplementations()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(
                baseTypeCache.GetTypes(typeof(IInterfaceForValueType)),
                Is.EquivalentTo(new[] { typeof(IInterfaceForValueType), typeof(ValueTypeWithInterface) }));
        }
        public void GetTypes_ForInterface_ReturnsInterfaceAndImplementations()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(
                baseTypeCache.GetTypes(typeof(ILongHairedBreed)),
                Is.EquivalentTo(new[] { typeof(ILongHairedBreed), typeof(MaineCoon), typeof(Siberian) }));
        }
        public void GetTypes_WholeHierarchy()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(
                baseTypeCache.GetTypes(typeof(Pet)),
                Is.EquivalentTo(new[] { typeof(Cat), typeof(Pet), typeof(Dog), typeof(MaineCoon), typeof(Ragdoll), typeof(Siberian) }));
        }
        public void GetTypes_ForInterfaceWithImplementationButNotPartOfTestDomain_ReturnsImplementations()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(baseTypeCache.GetTypes(typeof(ICloneable)), Is.EquivalentTo(new[] { typeof(Siberian) }));
        }
        public void GetTypes_ForInterfaceWithoutImplementations_ReturnsInterface()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(baseTypeCache.GetTypes(typeof(IHamster)), Is.EquivalentTo(new[] { typeof(IHamster) }));
        }
        public void GetTypes_NoDescendingTypes()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(baseTypeCache.GetTypes(typeof(MaineCoon)), Is.EqualTo(new[] { typeof(MaineCoon) }));
        }
        public void GetTypes_ForObject_ContainsIntefaceWithoutImplementations()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(baseTypeCache.GetTypes(typeof(object)), Contains.Item(typeof(IHamster)));
        }
        public void GetTypes_ForObject_ReturnsAllTypes()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(baseTypeCache.GetTypes(typeof(object)), Is.EquivalentTo(_testDomain.Concat(new[] { typeof(object), typeof(ValueType), typeof(ICloneable) })));
        }
        public void GetTypes_ForValueTypeFromGac_ReturnsEmptyList()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(baseTypeCache.GetTypes(typeof(Decimal)), Is.Empty);
        }
        public void GetTypes_ForValueType_ReturnsType()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(baseTypeCache.GetTypes(typeof(ValueTypeWithInterface)), Is.EquivalentTo(new[] { typeof(ValueTypeWithInterface) }));
        }
        public void GetTypes_ForTypeNotPartOfTestDomain_ReturnsEmptyList()
        {
            var baseTypeCache = BaseTypeCache.Create(_testDomain);

            Assert.That(baseTypeCache.GetTypes(typeof(BaseTypeCacheTest)), Is.Empty);
        }