/// <summary>
        /// Creates a cache dependency based on the specified virtual paths.
        /// </summary>
        /// <param name="definition">The definition.</param>
        /// <param name="virtualPath">The path to the primary virtual resource.</param>
        /// <returns>
        /// A <see cref="T:System.Web.Caching.CacheDependency"/> object for the specified virtual resources.
        /// </returns>
        public virtual CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
        {
            CacheDependency result = this.GetCurrentCacheDependency(definition, virtualPath, virtualPathDependencies, utcStart);

            //If the requested file does not exist in the current resolver then keep these dependencies and add dependencies of the next resolver.
            //This will allow the resolvers higher in the chain to be pinged again when the file might be available to them.
            if (this.Next != null && !this.CurrentExists(definition, virtualPath))
            {
                var nextDependencies = this.Next.GetCacheDependency(definition, virtualPath, virtualPathDependencies, utcStart);
                if (nextDependencies != null)
                {
                    if (result != null)
                    {
                        var aggr = new AggregateCacheDependency();
                        aggr.Add(result, nextDependencies);
                        result = aggr;
                    }
                    else
                    {
                        result = nextDependencies;
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// Determines whether a file with the specified virtual path exists.
        /// </summary>
        /// <param name="virtualPath">The virtual path to check.</param>
        public virtual bool Exists(PathDefinition definition, string virtualPath)
        {
            virtualPath = this.RemoveParams(virtualPath);

            var resolverStrategy = ObjectFactory.Resolve<IResourceResolverStrategy>();
            return resolverStrategy.Exists(definition, virtualPath);
        }

        /// <summary>
        /// Creates a cache dependency based on the specified virtual paths.
        /// </summary>
        /// <param name="definition">The definition.</param>
        /// <param name="virtualPath">The path to the primary virtual resource.</param>
        /// <returns>
        /// A <see cref="T:System.Web.Caching.CacheDependency"/> object for the specified virtual resources.
        /// </returns>
        public virtual CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
        {
            virtualPath = this.virtualPathBuilder.RemoveParams(virtualPath);

            var resolverStrategy = ObjectFactory.Resolve<IResourceResolverStrategy>();
            return resolverStrategy.GetCacheDependency(definition, virtualPath, virtualPathDependencies, utcStart);
        }

        /// <summary>
        /// Opens the the file with the specified virtual path.
        /// </summary>
        /// <param name="virtualPath">The virtual path of the file to open.</param>
        public virtual Stream Open(PathDefinition definition, string virtualPath)
        {
            virtualPath = this.virtualPathBuilder.RemoveParams(virtualPath);

            var resolverStrategy = ObjectFactory.Resolve<IResourceResolverStrategy>();
            return resolverStrategy.Open(definition, virtualPath);
        }

 /// <summary>
 /// Gets the control presentation that contains the requested resource from the database.
 /// </summary>
 /// <param name="virtualPathDefinition">The definition.</param>
 /// <param name="virtualPath">The virtual path.</param>
 /// <returns></returns>
 protected override ControlPresentation GetControlPresentation(PathDefinition virtualPathDefinition, string virtualPath)
 {
     if (this.ControlPresentationResult.ContainsKey(virtualPath))
         return this.ControlPresentationResult[virtualPath];
     else
         return null;
 }

        /// <summary>
        /// Opens the the file with the specified virtual path.
        /// </summary>
        /// <param name="definition">The definition.</param>
        /// <param name="virtualPath">The virtual path of the file to open.</param>
        /// <returns></returns>
        public virtual Stream Open(PathDefinition definition, string virtualPath)
        {
            if (this.Next != null && !this.CurrentExists(definition, virtualPath))
                return this.Next.Open(definition, virtualPath);

            return this.CurrentOpen(definition, virtualPath);
        }

 /// <inheritdoc />
 protected override Stream CurrentOpen(PathDefinition definition, string virtualPath)
 {
     Assembly assembly = this.GetAssembly(definition);
     var resourceName = this.GetResourceName(definition, virtualPath);
     var resources = assembly.GetManifestResourceNames();
     var caseSensitiveName = resources.First(r => string.Equals(resourceName, r, StringComparison.OrdinalIgnoreCase));
     var stream = assembly.GetManifestResourceStream(caseSensitiveName);
     return stream;
 }

 /// <inheritdoc />
 public override bool Exists(PathDefinition definition, string virtualPath)
 {
     if (this.ExistsMock != null)
     {
         return this.ExistsMock(definition, virtualPath);
     }
     else
     {
         return base.Exists(definition, virtualPath);
     }
 }

        /// <inheritdoc />
        protected override bool CurrentExists(PathDefinition definition, string virtualPath)
        {
            if (definition.ResourceLocation.IsNullOrEmpty())
                return false;

            Assembly assembly = this.GetAssembly(definition);
            var resourceName = this.GetResourceName(definition, virtualPath);
            var resources = assembly.GetManifestResourceNames();

            return resources.Contains(resourceName, StringComparer.OrdinalIgnoreCase);
        }

        /// <inheritdoc />
        protected override IEnumerable<string> GetCurrentFiles(PathDefinition definition, string path)
        {
            var mappedPath = this.GetFileName(definition, path);
            if (mappedPath != null && Directory.Exists(mappedPath))
            {
                return Directory.GetFiles(mappedPath)
                                .Select(f => f.Replace(mappedPath, path));
            }

            return null;
        }

        /// <inheritdoc />
        protected override Stream CurrentOpen(PathDefinition definition, string virtualPath)
        {
            var controlPresentation = this.GetControlPresentation(definition, virtualPath);
            if (controlPresentation != null && !controlPresentation.Data.IsNullOrEmpty())
            {
                var bytes = RouteHelper.GetContentWithPreamble(controlPresentation.Data);
                return new MemoryStream(bytes);
            }

            throw new ArgumentException("Could not find resource at " + virtualPath + " in the database.");
        }

        /// <summary>
        /// Gets the control presentation that contains the requested resource from the database.
        /// </summary>
        /// <param name="definition">The definition.</param>
        /// <param name="virtualPath">The virtual path.</param>
        protected virtual ControlPresentation GetControlPresentation(PathDefinition definition, string virtualPath)
        {
            var resourceName = VirtualPathUtility.ToAppRelative(virtualPath);
            var areaName = VirtualPathUtility.AppendTrailingSlash(VirtualPathUtility.ToAppRelative(definition.VirtualPath));
            var extension = VirtualPathUtility.GetExtension(virtualPath).ToLower();

            var controlPresentation = PageManager.GetManager().GetPresentationItems<ControlPresentation>()
                .FirstOrDefault(cp => cp.AreaName == areaName && cp.NameForDevelopers == resourceName
                    && cp.DataType == extension);
            return controlPresentation;
        }

        /// <inheritdoc />
        protected override CacheDependency GetCurrentCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
        {
            var controlPresentation = this.GetControlPresentation(definition, virtualPath);
            if (controlPresentation != null)
            {
                return new ControlPresentationCacheDependency(controlPresentation.Id.ToString());
            }

            // Change to any ControlPresentation record will invalidate the cache for this virtual path.
            return new ControlPresentationCacheDependency(typeof(ControlPresentation));
        }

 /// <inheritdoc />
 public override CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
 {
     if (this.GetCacheDependencyMock != null)
     {
         return this.GetCacheDependencyMock(definition, virtualPath, virtualPathDependencies, utcStart);
     }
     else
     {
         return base.GetCacheDependency(definition, virtualPath, virtualPathDependencies, utcStart);
     }
 }

 public System.Web.Caching.CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
 {
     var id = this.ResolveFormDescriptionId(virtualPath);
     if (id != null && this.DescriptionExists(id.Value))
     {
         return new DataItemSystemCacheDependency(typeof(FormDescription), itemId: id.Value.ToString("D"));
     }
     else
     {
         return new DataItemSystemCacheDependency(typeof(FormDescription));
     }
 }

        /// <inheritdoc />
        protected override IEnumerable<string> GetCurrentFiles(PathDefinition definition, string path)
        {
            var resourceName = this.GetResourceName(definition, path);
            if (resourceName != null)
            {
                var assembly = this.GetAssembly(definition);
                return assembly.GetManifestResourceNames()
                    .Where(r => r.StartsWith(resourceName, StringComparison.OrdinalIgnoreCase))
                    .Select(r => r.Replace(resourceName, path));
            }

            return null;
        }

        public void GetLayoutName_VirtualPath_ResolvesLayoutFileName()
        {
            // Arrange
            var expectedLayoutName = "TestTitle";
            var testVirtualPath = "~/TestPrefix/TestTitle....master";
            var pathDefinition = new PathDefinition { VirtualPath = "~/TestPrefix" };

            // Act
            var layoutVirtualPathBuilder = new LayoutVirtualPathBuilder();
            var resultLayoutName = layoutVirtualPathBuilder.GetLayoutName(pathDefinition, testVirtualPath);

            // Assert
            Assert.AreEqual(expectedLayoutName, resultLayoutName, "The layout name is not extracted correctly.");
        }

        public void GetLayoutName_WithoutMasterSuffix_ReturnsNull()
        {
            // Arrange
            var testVirtualPath = "~/TestPrefix/TestTitle.test";
            var pathDefinition = new PathDefinition();
            pathDefinition.VirtualPath = "~/TestPrefix";

            // Act
            var layoutVirtualPathBuilder = new LayoutVirtualPathBuilder();
            var resultLayoutName = layoutVirtualPathBuilder.GetLayoutName(pathDefinition, testVirtualPath);

            // Assert
            Assert.IsNull(resultLayoutName, "The result layout name should be null if the virtual path doesn't end with 'master'.");
        }

        /// <summary>
        /// Creates a cache dependency based on the specified virtual paths.
        /// </summary>
        /// <param name="definition">The definition.</param>
        /// <param name="virtualPath">The path to the primary virtual resource.</param>
        /// <returns>
        /// A <see cref="T:System.Web.Caching.CacheDependency"/> object for the specified virtual resources.
        /// </returns>
        public CacheDependency GetCacheDependency(PathDefinition definition, string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
        {
            virtualPath = this.virtualPathBuilder.RemoveParams(virtualPath);
            virtualPath = VirtualPathUtility.ToAppRelative(virtualPath);

            var layoutVirtualPathBuilder = new LayoutVirtualPathBuilder();
            string viewName = layoutVirtualPathBuilder.GetLayoutName(definition, virtualPath);
            var layoutTemplateBuilder = new LayoutRenderer();

            if (string.IsNullOrEmpty(viewName))
                return null;

            var viewPath = layoutTemplateBuilder.LayoutViewPath(viewName);
            return HostingEnvironment.VirtualPathProvider.GetCacheDependency(viewPath, virtualPathDependencies, utcStart);
        }

        /// <summary>
        /// Gets the layout file name from virtual path.
        /// </summary>
        /// <param name="definition">The definition.</param>
        /// <param name="virtualPath">The virtual path.</param>
        /// <returns></returns>
        public virtual string GetLayoutName(PathDefinition definition, string virtualPath)
        {
            if (!virtualPath.EndsWith(LayoutVirtualPathBuilder.LayoutSuffix, StringComparison.OrdinalIgnoreCase))
                return null;

            var definitionVp = VirtualPathUtility.AppendTrailingSlash(VirtualPathUtility.ToAppRelative(definition.VirtualPath));
            var pageTemplateNameLength = virtualPath.Length - definitionVp.Length - LayoutVirtualPathBuilder.LayoutSuffix.Length - 1;
            string pageTemplateName = virtualPath.Substring(definitionVp.Length, pageTemplateNameLength);

            while (!string.IsNullOrEmpty(pageTemplateName) && pageTemplateName.EndsWith(".", StringComparison.Ordinal))
            {
                pageTemplateName = pageTemplateName.Substring(0, pageTemplateName.Length - 1);
            }

            return pageTemplateName;
        }