Inheritance: IDependencyResolver
        public void Resolve_WithAbritraryParameters_ReturnsResultCorrectly()
        {
            Func<ISymbol, Maybe<object>> strategy = _ => "Baz".ToMaybe<object>();

            var resolver = new DependencyResolver(strategy);
            var result = resolver.Resolve(typeof (IDisposable), "Foo");

            Assert.AreEqual("Baz", result);
        }
        public void Resolve_WithKeyAndRequestingType_ReturnsExpectedValue()
        {
            var resolver = new DependencyResolver(x => x
                .ToMaybe()
                .OfType<IDependencySymbol>()
                .Where(s => s.DependencyType == typeof(int) && s.Name == "ultimateAnswerTimesThree")
                .Select(s => 126).OfType<object>());

            Ioc.SetDependencyResolver(resolver);

            Assert.AreEqual(126, Ioc.Resolve<int>("ultimateAnswerTimesThree"));
            Assert.AreEqual(126, Ioc.Resolve(typeof(int), "ultimateAnswerTimesThree"));
        }
        public void Resolve_WithNoParameters_ReturnsExpectedValue()
        {
            var resolver = new DependencyResolver(x => x
                .ToMaybe()
                .OfType<IDependencySymbol>()
                .Where(s => s.DependencyType == typeof(int))
                .Select(s => 42).OfType<object>());

            Ioc.SetDependencyResolver(resolver);

            Assert.AreEqual(42, Ioc.Resolve<int>());
            Assert.AreEqual(42, Ioc.Resolve(typeof(int)));
        }
        public void Resolve_WithAbritraryParameters_CallsResolutionStrategyCorrectly()
        {
            string name = null;
            Type dependencyType = null;

            Func<ISymbol, Maybe<object>> strategy = symbol =>
                                                {
                                                    name = ((IDependencySymbol) symbol).Name;
                                                    dependencyType = ((IDependencySymbol) symbol).DependencyType;
                                                    return Maybe<object>.NoValue;
                                                };

            var resolver = new DependencyResolver(strategy);
            resolver.Resolve(typeof(IDisposable), "Foo");

            Assert.AreEqual("Foo", name);
            Assert.AreEqual(typeof(IDisposable), dependencyType);

        }