/// <summary>
		/// Resolve the parameter for the expected type. The method will return <code>null</code>
		/// If the expected type is not one of the collection types {@link Array},
		/// {@link Collection}or {@link Map}. An empty collection is only a valid resolution, if
		/// the <code>emptyCollection</code> flag was set.
		/// </summary>
		/// <param name="container"></param>
		/// <param name="adapter"></param>
		/// <param name="expectedType"></param>
		/// <returns>the instance of the collection type or <code>null</code></returns>
		public Object ResolveInstance(IPicoContainer container, IComponentAdapter adapter, Type expectedType)
		{
			// type check is done in isResolvable
			Object result = null;
			Type collectionType = GetCollectionType(expectedType);
			if (collectionType != null)
			{
				IDictionary dictionary = GetMatchingComponentAdapters(container, adapter, componentKeyType, GetValueType(expectedType));
				if (typeof (Array).IsAssignableFrom(collectionType))
				{
					result = GetArrayInstance(container, expectedType, dictionary);
				}
				else if (typeof (IDictionary).IsAssignableFrom(collectionType))
				{
					result = GetDictionaryInstance(container, expectedType, dictionary);
				}
				else if (typeof (ICollection).IsAssignableFrom(collectionType))
				{
					result = GetCollectionInstance(container, expectedType, dictionary);
				}
				else
				{
					throw new PicoIntrospectionException(expectedType.Name + " is not a collective type");
				}
			}
			return result;
		}

        protected virtual IPicoContainer WrapComponentInstances(Type decoratingComponentAdapterClass,
                                                                IPicoContainer picoContainer,
                                                                object[] wrapperDependencies)
        {
            Assert.IsTrue(typeof (DecoratingComponentAdapter).IsAssignableFrom(decoratingComponentAdapterClass));
            IMutablePicoContainer mutablePicoContainer = new DefaultPicoContainer();
            int size = (wrapperDependencies != null ? wrapperDependencies.Length : 0) + 1;
            ICollection allComponentAdapters = picoContainer.ComponentAdapters;

            foreach (object adapter in allComponentAdapters)
            {
                IParameter[] parameters = new IParameter[size];
                parameters[0] = new ConstantParameter(adapter);
                for (int i = 1; i < parameters.Length; i++)
                {
                    parameters[i] = new ConstantParameter(wrapperDependencies[i - 1]);
                }
                IMutablePicoContainer instantiatingPicoContainer =
                    new DefaultPicoContainer(new ConstructorInjectionComponentAdapterFactory());
                instantiatingPicoContainer.RegisterComponentImplementation("decorator", decoratingComponentAdapterClass,
                                                                           parameters);
                mutablePicoContainer.RegisterComponent(
                    (IComponentAdapter) instantiatingPicoContainer.GetComponentInstance("decorator"));
            }
            return mutablePicoContainer;
        }

 /// <summary>
 /// Creates a new container with a parent container.
 /// </summary>
 /// <param name="caf"></param>
 /// <param name="parent"></param>
 /// <param name="lifecycleManager"></param>
 public ImplementationHidingPicoContainer(IComponentAdapterFactory caf, IPicoContainer parent,
                                          ILifecycleManager lifecycleManager)
     : base(new DefaultPicoContainer(caf, parent, lifecycleManager))
 {
     this.caf = caf;
     this.lifecycleManager = lifecycleManager;
 }

 /// <summary>
 /// Creates a new container with a parent container.
 /// </summary>
 /// <param name="caf"></param>
 /// <param name="parent"></param>
 /// <param name="lifecycleManager"></param>
 public CachingPicoContainer(CachingComponentAdapterFactory caf, IPicoContainer parent,
                             ILifecycleManager lifecycleManager)
     : base(new DefaultPicoContainer(caf, parent, lifecycleManager))
 {
     this.lifecycleManager = lifecycleManager;
     this.caf = caf;
 }

 protected override IMutablePicoContainer CreatePicoContainer(IPicoContainer parent,
                                                              ILifecycleManager lifecycleManager)
 {
     return
         new ImplementationHidingCachingPicoContainer(
             new CachingComponentAdapterFactory(new DefaultComponentAdapterFactory()), parent, lifecycleManager);
 }

		protected virtual IMutablePicoContainer CreateContainerFromScript(IPicoContainer parentContainer,
		                                                                  IList assemblies)
		{
			IScript script = CreateScript(assemblies);
			script.Parent = parentContainer;
			return script.Compose();
		}

        public override Object GetComponentInstance(IPicoContainer container)
        {
            Object componentKey = Delegate.ComponentKey;
            Type[] types;
            if (componentKey is Type && ((Type) Delegate.ComponentKey).IsInterface)
            {
                types = new Type[] {(Type) Delegate.ComponentKey};
            }
            else if (componentKey is Type[])
            {
                types = (Type[]) componentKey;
            }
            else
            {
                if (strict)
                {
                    throw new PicoIntrospectionException("In strict mode, "
                                                         + GetType().Name
                                                         +
                                                         " only allows components registered with interface keys (System.Type or System.Type[])");
                }
                return Delegate.GetComponentInstance(container);
            }

            return CreateProxy(types, container);
        }

 private ImplementationHidingCachingPicoContainer(IPicoContainer parent, CachingComponentAdapterFactory caf,
                                                  ILifecycleManager lifecycleManager)
     : base(new ImplementationHidingPicoContainer(caf, parent, lifecycleManager))
 {
     this.caf = caf;
     this.lifecycleManager = lifecycleManager;
 }

 protected override IMutablePicoContainer CreatePicoContainer(IPicoContainer parent)
 {
     return
         new DefaultPicoContainer(
             new CachingComponentAdapterFactory(
                 new ImplementationHidingComponentAdapterFactory(
                     new ConstructorInjectionComponentAdapterFactory(), false)), parent);
 }

		/// <summary>
		/// Gets the component instance. Only one instance is created of the type
		/// </summary>
		/// <returns>a component instance</returns>
		/// <exception cref="PicoContainer.PicoInitializationException">if the component could not be instantiated.</exception>    
		/*public override object ComponentInstance
		{
			get
			{
				if (instanceReference.Get() == null)
				{
					instanceReference.Set(base.ComponentInstance);
				}
				return instanceReference.Get();
			}

		}*/

		public override object GetComponentInstance(IPicoContainer container)
		{
			if (instanceReference.Get() == null)
			{
				instanceReference.Set(base.GetComponentInstance(container));
			}
			return instanceReference.Get();
		}

 public override object GetComponentInstance(IPicoContainer container)
 {
     if (constructorInjectionGuard == null)
     {
         constructorInjectionGuard = new ConstructorInjectionGuard(this, container);
     }
     return constructorInjectionGuard.Observe(ComponentImplementation);
 }

		public virtual void Dispose(IPicoContainer node)
		{
			IList disposables = node.GetComponentInstancesOfType(typeof (IDisposable));
			for (int i = disposables.Count - 1; 0 <= i; i--)
			{
				DoMethod(disposeMethod, disposables[i]);
			}
		}

		protected IPicoContainer BuildContainer(ScriptedContainerBuilder builder, IPicoContainer parentContainer, IList assemblies)
		{
			SimpleReference sr = new SimpleReference();
			SimpleReference pr = new SimpleReference();
			pr.Set(parentContainer);
			builder.BuildContainer(sr, pr, assemblies);
			return (IPicoContainer) sr.Get();
		}

		public virtual void Start(IPicoContainer node)
		{
			IList startables = node.GetComponentInstancesOfType(typeof (IStartable));

			foreach (object startable in startables)
			{
				DoMethod(startMethod, startable);
			}
		}

        public override void Verify(IPicoContainer container)
        {
            if (verifyingGuard == null)
            {
                verifyingGuard = new DefaultVerifyingGuard(this, container);
            }

            verifyingGuard.Observe(ComponentImplementation);
        }

 public void Verify(IPicoContainer container, IComponentAdapter adapter, Type expectedType)
 {
     if (!expectedType.IsInstanceOfType(constantValue))
     {
         throw new PicoIntrospectionException(expectedType.FullName
                                              + " is not assignable from "
                                              + constantValue.GetType().FullName);
     }
 }

 public virtual object ResolveInstance(IPicoContainer container, IComponentAdapter adapter, Type expectedType)
 {
     IComponentAdapter componentAdapter = ResolveAdapter(container, adapter, expectedType);
     if (componentAdapter != null)
     {
         return container.GetComponentInstance(componentAdapter.ComponentKey);
     }
     return null;
 }

		public virtual void Stop(IPicoContainer node)
		{
			IList startables = node.GetComponentInstancesOfType(typeof (IStartable));

			for (int i = startables.Count - 1; 0 <= i; i--)
			{
				DoMethod(stopMethod, startables[i]);
			}
		}

        public virtual void Verify(IPicoContainer container, IComponentAdapter adapter, Type expectedType)
        {
            IComponentAdapter componentAdapter = ResolveAdapter(container, adapter, expectedType);
            if (componentAdapter == null)
            {
                throw new PicoIntrospectionException(expectedType.Name + " is not resolvable");
            }

            componentAdapter.Verify(container);
        }

		protected void SetUp()
		{
			events = new StringBuilder();
			one = new TestComponent("One", events);
			two = new TestComponent("Two", events);
			three = new TestComponent("Three", events);

			mock = new DynamicMock(typeof (IPicoContainer));
			pico = (IPicoContainer) mock.MockInstance;
		}