public void Check(ConstructorInfo info, Dependency parent)
 {
     if (info.IsPrivate && !info.ReflectedType.IsAbstract)
     {
         parent.Add(new ProblemDependency(string.Format("This is a private constructor")));
     }
 }

        public static SqlServerDocumentDbRegistration RegisterSqlServerDocumentDb
            (this IWindsorContainer @this,
             SqlServerDocumentDbRegistration registration,
             string connectionName,
             Dependency sessionInterceptor = null)
        {
            Contract.Requires(registration != null);
            Contract.Requires(!connectionName.IsNullOrWhiteSpace());

            //We don't want to get any old interceptor that might have been registered by someone else.
            sessionInterceptor = sessionInterceptor ?? Dependency.OnValue<IDocumentDbSessionInterceptor>(NullOpDocumentDbSessionInterceptor.Instance);

            var connectionString = Dependency.OnValue(typeof(string),@this.Resolve<IConnectionStringProvider>().GetConnectionString(connectionName).ConnectionString);

            @this.Register(
                Component.For<IDocumentDb>()
                         .ImplementedBy<SqlServerDocumentDb>()
                         .DependsOn(connectionString)
                    .LifestylePerWebRequest()
                    .Named(registration.DocumentDbName),
                Component.For(Seq.OfTypes<IDocumentDbSession, IDocumentDbUpdater, IDocumentDbReader, IDocumentDbBulkReader, IUnitOfWorkParticipant, IDocumentUpdatedNotifier>())
                         .ImplementedBy<DocumentDbSession>()
                         .DependsOn(registration.DocumentDb, sessionInterceptor)
                         .LifestylePerWebRequest()
                         .Named(registration.SessionName)
                );

            @this.WhenTesting()
                 .ReplaceDocumentDb(registration.DocumentDbName);

            return registration;
        }

 public void Check(MethodInfo info, Dependency parent)
 {
     if (!info.IsFinal && (info.IsVirtual || info.IsAbstract))
     {
         parent.Add(new Dependency(string.Format(" {0}() can be overriden", info.Name)));
     }
 }

        public void Standard() {
            var dep = new Dependency("@cba_a3-1.0.0.4");

            dep.Name.Should().Be("@cba_a3");
            dep.Version.Should().Be("1.0.0.4");
            dep.Branch.Should().BeNull();
        }

        public void SpecialVersion() {
            var dep = new Dependency("@cba_a3-1983.12.24");

            dep.Name.Should().Be("@cba_a3");
            dep.Version.Should().Be("1983.12.24");
            dep.Branch.Should().BeNull();
        }

        public void SpecialVersionConstraintsWithBranch() {
            var dep = new Dependency("@cba_a3->=1.0.0.4-beta");

            dep.Name.Should().Be("@cba_a3");
            dep.Version.Should().Be(">=1.0.0.4");
            dep.Branch.Should().Be("beta");
        }

        public void JustName() {
            var dep = new Dependency("@cba_a3");

            dep.Name.Should().Be("@cba_a3");
            dep.Version.Should().BeNull();
            dep.Branch.Should().BeNull();
        }

        public void SpecialName2() {
            var dep = new Dependency("@cba_a3-xx-1-1-1.0.2-beta");

            dep.Name.Should().Be("@cba_a3-xx-1-1");
            dep.Version.Should().Be("1.0.2");
            dep.Branch.Should().Be("beta");
        }

        public void CollectsAllBindingsAndLoadsThemDistinctOnKernel()
        {
            var loadedModules = new List<INinjectModule>();

            A.CallTo(() => this.kernel.Load(A<IEnumerable<INinjectModule>>._))
                .Invokes((IEnumerable<INinjectModule> modules) => loadedModules.AddRange(modules));

            var dependencyA = new DependencyA();
            var dependencyB = new DependencyB();

            var dependencyDefinitionA = new Dependency<IDependencyA>(bind => bind.ToConstant(dependencyA).InTransientScope());
            var dependencyDefinitionB = new Dependency<IDependencyB>(bind => bind.ToConstant(dependencyB).InSingletonScope());

            this.testee.Load(
                new FeatureA(
                    dependencyDefinitionA,
                    dependencyDefinitionB),
                new FeatureB(
                    dependencyDefinitionA,
                    dependencyDefinitionB),
                new FeatureC());

            loadedModules.Select(_ => _.GetType().Name)
                .Should().Contain(
                    new[] 
                    {
                        typeof(ModuleA),
                        typeof(ModuleB),
                        typeof(ModuleC),
                        typeof(ModuleD)
                    }.Select(_ => _.Name))
                    .And.BeEquivalentTo(loadedModules.Select(_ => _.GetType().Name).Distinct());
        }

        /// <summary>
        ///     注册依赖服务对象
        /// </summary>
        /// <param name="dependency">依赖服务对象</param>
        /// <exception cref="ArgumentNullException"></exception>
        public void RegisterDependency(Dependency dependency)
        {
            if (dependency == null)
                throw new ArgumentNullException(nameof(dependency));

            _container.Add(dependency);
        }

		private object ConvertIdentifier(
			object value,
			Item item,
			Direction direction,
			Guid providerId,
			string itemType)
		{
			if (value != null && !string.IsNullOrWhiteSpace(value.ToString()))
			{
				if (direction == Direction.Packaging)
				{
					var guid = Dependencies.ConvertIdentifier(value.ToString(), IdentifierReplaceDirection.FromNodeIdToGuid);

					// add dependency for the item
					var name = string.Concat(itemType, " from picker");
					var dependency = new Dependency(name, guid, providerId);
					item.Dependencies.Add(dependency);

					return guid;
				}
				else if (direction == Direction.Extracting)
				{
					return Dependencies.ConvertIdentifier(value.ToString(), IdentifierReplaceDirection.FromGuidToNodeId);
				}
			}

			return value;
		}

		public void IsMajorConflict_returns_false_for_identical_version_numbers() {
			var dependency = new Dependency();
			dependency.LibAssembly = GetNewAssemblyNameWithVersion(1, 2, 3, 4);
			dependency.ReferencedAssembly = GetNewAssemblyNameWithVersion(1, 2, 3, 4);

			Assert.That(dependency.IsMajorConflict, Is.False, "should not report a conflict if the version numbers are identical");
		}

        public void Check(FieldInfo info, Dependency parent)
        {
            //            Dependency parent = new Dependency(info.);
            bool isInterface = info.FieldType.IsInterface;
            bool isAbstract = info.FieldType.IsAbstract;
            bool isNotSealed = !info.FieldType.IsSealed;

            string message = "";
            if (isInterface)
            {
                message = string.Format("Field {0} is interface {1}", info.Name, info.FieldType.Name);
            }
            else if (isAbstract)
            {
                message = string.Format("Field {0} is an abstract class {1} and can be inherited from", info.Name,info.FieldType.Name);

            }
            else if (isNotSealed)
            {
                message =
                    string.Format("Field {0} is non sealed {1} and can be inherited from", info.Name,
                                  info.FieldType.Name);
            }

            parent.Add(new Dependency(message));
            //            if (parent.AlreadyContains(info.FieldType))
            //            {
            //                parent.Add(new Dependency(message));
            //            }
            //            else
            //            {
            //                parent.Add(new Dependency(info.FieldType, message));
            //            }
        }

        public void IsConflicted_returns_true_for_conflict_of_nonbreaking_change_number()
        {
			var dependency = new Dependency();
			dependency.LibAssembly = GetNewAssemblyNameWithVersion(1, 2, 5, 4);
			dependency.ReferencedAssembly = GetNewAssemblyNameWithVersion(1, 2, 3, 4);

			Assert.That(dependency.IsConflicted, Is.True, "should report a minor conflict if the version numbers are not the same");
		}

		public void IsMajorConflict_returns_false_for_version_numbers_with_only_3rd_and_4th_number_different()
		{
			var dependency = new Dependency();
			dependency.LibAssembly = GetNewAssemblyNameWithVersion(1, 2, 5, 4);
			dependency.ReferencedAssembly = GetNewAssemblyNameWithVersion(1, 2, 3, 8);

			Assert.That(dependency.IsMajorConflict, Is.False, "should not report a conflict if the version numbers are same except for 3rd and 4th numbers");
		}

		public void IsMajorConflict_returns_true_for_version_numbers_with_1st_number_different()
		{
			var dependency = new Dependency();
			dependency.LibAssembly = GetNewAssemblyNameWithVersion(2, 2, 3, 8);
			dependency.ReferencedAssembly = GetNewAssemblyNameWithVersion(1, 2, 3, 8);

			Assert.That(dependency.IsMajorConflict, Is.True, "should report a conflict if the version number 1st number is different");
		}

        public static void Composition()
        {
            var dependency = new Dependency();

            var thing = new Thing(dependency);

            var relyOnThing = new RelyOnThing(thing);
        }

 protected override void Before_each_spec()
 {
     packageTree = CreateStub<IPackageTree>();
     dependency = new Dependency("Test", "Test");
     updater = CreateStub<IDependentUpdater>();
     dependencyPaths = new List<string>();
     executor = new DependentUpdaterExecutor(new[] { updater });
 }

 public static CacheDependency Get( string key )
 {
     Dependency dep = new Dependency(key);
     lock (deps)
     {
         deps.Add(dep);
     }
     return dep;
 }

        public void Can_register_and_resolve_a_list_with_an_explicit_type_provided_to_SetInstance()
        {
            var dependency = new Dependency();
            var list = new List<Dependency>();
            list.Add(dependency);

            mocker.SetInstance<IList<Dependency>>(list);
            var thing = mocker.Create<ThingThatHasDependencies>();

            thing.FindOne().ShouldBeSameAs(dependency);
        }