protected void when_finding_packages(string dependency)
            {
                var dep = new PackageDescriptor();
                ((IPackageDescriptor)dep).Dependencies.Add(DependsParser.ParseDependsLine(dependency));

                FoundPackage = Repository.PackagesByName.FindAll(dep.Dependencies.First()).FirstOrDefault();
            }

            protected void when_finding_packages(string dependency)
            {
                var dep = new PackageDescriptor();
                new DependsParser().Parse(dependency, dep);

                FoundPackage = Repository.FindAll(dep.Dependencies.First()).FirstOrDefault();
            }

 public void Parse(string line, PackageDescriptor descriptor)
 {
     var match = _regex.Match(line);
     if (!match.Success)
         return;
     ParseContent(match.Groups["content"].Value, descriptor);
 }

 public static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(this IPackageResolver resolver,
     bool includeContentOnly,
     ExecutionEnvironment exec,
     PackageDescriptor descriptor,
     params IPackageRepository[] repositories)
 {
     return GetAssemblyReferences(resolver.TryResolveDependencies(descriptor, repositories), exec, includeContentOnly);
 }

        public IPackageCleanResult CleanProjectPackages(PackageDescriptor packages, IPackageRepository projectRepository, string name, PackageCleanOptions options = PackageCleanOptions.Default)
        {
            if (packages == null) throw new ArgumentNullException("packages");
            if (projectRepository == null) throw new ArgumentNullException("projectRepository");

            var repoForClean = projectRepository as ISupportCleaning;
            if (repoForClean == null) throw new ArgumentException("projectRepository must implement ISupportCleaning");
            return new PackageCleanResultIterator(CleanProjectPackagesCore(packages, repoForClean, x => name.EqualsNoCase(x)));
        }

 public DefaultPackageInfo(string packageFileName, Version versionFileContent, PackageDescriptor descriptor)
 {
     _descriptor = descriptor;
     _packageVersion = versionFileContent
                       ?? descriptor.Version
                       ?? PackageNameUtility.GetVersion(packageFileName);
     _packageName = PackageNameUtility.GetName(packageFileName);
     Identifier = new PackageIdentifier(Name, Version);
 }

 public static IPackageDescriptor Lock(this IPackageDescriptor descriptor, IPackageRepository repository, string scope = null)
 {
     scope = scope ?? string.Empty;
     var lockedRepo = repository.Feature<ISupportLocking>();
     if (lockedRepo == null)
         return descriptor;
     var lockedDescriptor = new PackageDescriptor(descriptor);
     var lockedPackages = lockedRepo.LockedPackages[scope];
     return Lock(lockedDescriptor, lockedPackages);
 }

        public void Write(PackageDescriptor descriptor, Stream descriptorStream)
        {
            var streamWriter = new StreamWriter(descriptorStream, Encoding.UTF8);
            var lines = from parser in _lineParsers
                        from parserLine in parser.Write(descriptor)
                        select parserLine;

            var content = lines.Join("\r\n");
            streamWriter.Write(content);
            streamWriter.Flush();
        }

 public InMemoryEnvironment(IDirectory currentDirectory, IDirectory configDirectory)
 {
     CurrentDirectory = currentDirectory;
     SystemRepository = new InMemoryRepository("System repository");
     RemoteRepository = new InMemoryRepository("Remote repository");
     CurrentDirectoryRepository = new InMemoryRepository("Current directory repository");
     RemoteRepositories = new List<InMemoryRepository> { RemoteRepository };
     DescriptorFile = CurrentDirectory.GetFile("descriptor.wrapdesc");
     Descriptor = new PackageDescriptor();
     ConfigurationDirectory = configDirectory;
 }

 public dependency_resolver_context()
 {
     DependencyDescriptor = new PackageDescriptor
     {
             Name = "test",
             SemanticVersion = "1.0".ToSemVer()
     };
     ProjectRepository = new InMemoryRepository("Local repository");
     SystemRepository = new InMemoryRepository("System repository");
     RemoteRepository = new InMemoryRepository("Remote repository");
     CurrentDirectoryRepository = new InMemoryRepository("Current repository");
 }

        public PackageDescriptor Read(Stream content)
        {
            var stringReader = new StreamReader(content, true);
            var lines = stringReader.ReadToEnd().GetUnfoldedLines();

            var descriptor = new PackageDescriptor();
            foreach (var line in lines)
                foreach (var parser in _lineParsers)
                    parser.Parse(line, descriptor);

            return descriptor;
        }

 static PackageContent GenerateDescriptorFile(PackageDescriptor descriptor)
 {
     var descriptorStream = new MemoryStream();
     new PackageDescriptorReaderWriter().Write(descriptor, descriptorStream);
     return new PackageContent
     {
         FileName = descriptor.Name + ".wrapdesc",
         RelativePath = ".",
         Stream = descriptorStream.ResetOnRead(),
         Size = descriptorStream.Length
     };
 }

 public InMemoryEnvironment(IDirectory currentDirectory, IDirectory configDirectory)
 {
     CurrentDirectory = currentDirectory;
     SystemRepository = new InMemoryRepository("System repository");
     RemoteRepository = new InMemoryRepository("Remote repository");
     CurrentDirectoryRepository = new InMemoryRepository("Current directory repository");
     RemoteRepositories = new List<InMemoryRepository> { RemoteRepository };
     DescriptorFile = CurrentDirectory.GetFile("descriptor.wrapdesc").MustExist();
     Descriptor = new PackageDescriptor();
     ConfigurationDirectory = configDirectory;
     ScopedDescriptors = new Dictionary<string, FileBased<IPackageDescriptor>>(StringComparer.OrdinalIgnoreCase);
     ScopedDescriptors[string.Empty] = FileBased.New(DescriptorFile, Descriptor);
 }

        public IPackageAddResult AddProjectPackage(PackageRequest packageToAdd,
            IEnumerable<IPackageRepository> sourceRepositories,
            PackageDescriptor projectDescriptor,
            IPackageRepository projectRepository,
            PackageAddOptions options = PackageAddOptions.Default)
        {
            Check.NotNull(packageToAdd, "packageToAdd");
            Check.NoNullElements(sourceRepositories, "sourceRepositories");
            Check.NotNull(projectDescriptor, "projectDescriptor");
            Check.NotNull(projectRepository, "projectRepository");

            return new PackageAddResultIterator(AddProjectPackageCore(packageToAdd, sourceRepositories, projectDescriptor, projectRepository, options));
        }

 /// <summary>
 /// Retrieves a suitable package to put a certain type into.
 /// </summary>
 /// <param name="type">type for which a suitable package is desired</param>
 /// <returns>suitable package</returns>
 public PackageDescriptor GetPackage(Type type)
 {
     string pkgName = type.Namespace;
     if (pkgName == null)
         pkgName = "DefaultPackage";
     PackageDescriptor pd;
     if (!_pkgMap.TryGetValue(pkgName, out pd))
     {
         pd = new PackageDescriptor(pkgName);
     }
     _pkgMap[pkgName] = pd;
     _design.AddChild(pd, pd.Name);
     return pd;
 }

        public IEnumerable<KeyValuePair<string, bool?>> ExecuteAllTests(ExecutionEnvironment environment, IPackage package)
        {
            var descriptor = new PackageDescriptor();
            descriptor.Dependencies.Add(new PackageDependencyBuilder(Guid.NewGuid().ToString()).Name(package.Name).VersionVertex(new EqualVersionVertex(package.Version)));

            var allAssemblyReferences = _manager.GetProjectAssemblyReferences(descriptor, package.Source, environment, false);

            var runners = _factories.SelectMany(x => x.GetTestRunners(allAssemblyReferences)).NotNull();

            var tests = new DefaultAssemblyExporter("tests").Items<Exports.IAssembly>(package, environment);

            if (tests == null) return Enumerable.Empty<KeyValuePair<string, bool?>>();

            var testAssemblies = from item in tests.SelectMany(x=>x)
                                 where item.File.Extension.Equals(".dll")
                                 select item.File.Path.FullPath;
            return from runner in runners
                   from asm in testAssemblies
                   from result in runner.ExecuteTests(allAssemblyReferences.Select(x => x.File.Path.FullPath).ToList(), testAssemblies)
                   select result;
        }

        public IEnumerable<KeyValuePair<string, bool?>> ExecuteAllTests(ExecutionEnvironment environment, IPackage package)
        {
            var descriptor = new PackageDescriptor();
            descriptor.Dependencies.Add(new PackageDependencyBuilder(Guid.NewGuid().ToString()).Name(package.Name).VersionVertex(new EqualVersionVertex(package.Version)));

            var allAssemblyReferences = _resolver.GetAssemblyReferences(false, environment, descriptor, package.Source, _environment.ProjectRepository, _environment.SystemRepository);

            var runners = _factories.SelectMany(x=>x.GetTestRunners(allAssemblyReferences)).NotNull();

            var export = package.GetExport("tests", environment);

            if (export == null) return Enumerable.Empty<KeyValuePair<string, bool?>>();

            var testAssemblies = from item in export.Items
                                 where item.FullPath.EndsWithNoCase(".dll")
                                 select item.FullPath;
            return from runner in runners
                   from asm in testAssemblies
                   from result in runner.ExecuteTests(allAssemblyReferences.Select(x => x.FullPath).ToList(), testAssemblies)
                   select result;
        }

 public UncompressedPackage(IPackageRepository source,
     IFile originalPackageFile,
     IDirectory wrapCacheDirectory,
     IEnumerable<IExportBuilder> exporters)
 {
     _originalPackageFile = originalPackageFile;
     _exporters = exporters;
     BaseDirectory = wrapCacheDirectory;
     // get the descriptor file inside the package
     var descriptorName = originalPackageFile.NameWithoutExtension;
     Source = source;
     var wrapDescriptor = wrapCacheDirectory.Files("*.wrapdesc").SingleOrDefault();
     if (wrapDescriptor == null)
         throw new InvalidOperationException("Could not find descriptor in wrap cache directory, or there are multiple .wrapdesc files in the package.");
     var versionFile = wrapCacheDirectory.GetFile("version");
     _descriptor = new PackageDescriptorReaderWriter().Read(wrapDescriptor);
     PackageInfo = new DefaultPackageInfo(originalPackageFile.Name,
                                         versionFile.Exists ? versionFile.Read(x => x.ReadString().ToVersion()) : null,
                                         _descriptor);
     Identifier = new PackageIdentifier(Name, Version);
 }

 protected abstract void ParseContent(string content, PackageDescriptor descriptor);

        Version GetPackageVersion(IList<FileBuildResult> buildFiles, PackageDescriptor packageDescriptorForEmbedding)
        {
            // gets the package version from (in this order):
            // 1. 'version' file generated by the build
            // 2. 'version' file living alongside the .wrapdesc file
            // 3. 'version:' header in wrap descriptor

            return new DefaultPackageInfo(string.Empty, GetVersionFromVersionFiles(buildFiles), packageDescriptorForEmbedding).Version;
        }