@Test
  public void testResolveAndRethrowFailureWithNoMissingDependenciesShouldDoNothing()
      throws IOException, ParseException {
    ModuleDescriptor moduleDescriptor = createAnonymousModuleDescriptor();
    prepareTestsThatRetrieveDependencies(moduleDescriptor);
    prepareResolveReport();
    ResolvedConfiguration configuration = ivyDependencyResolver.resolve(configurationStub);

    assertFalse(configuration.hasError());
    configuration.rethrowFailure();
  }
  @Test
  public void testResolveAndRethrowFailureWithMissingDependenciesShouldThrowResolveException()
      throws IOException, ParseException {
    ModuleDescriptor moduleDescriptor = createAnonymousModuleDescriptor();
    prepareTestsThatRetrieveDependencies(moduleDescriptor);
    Exception failure = new Exception("broken");
    prepareResolveReportWithError(failure);
    ResolvedConfiguration configuration = ivyDependencyResolver.resolve(configurationStub);

    assertTrue(configuration.hasError());
    try {
      configuration.rethrowFailure();
      fail();
    } catch (ResolveException e) {
      assertThat(
          e.getMessage(), startsWith("Could not resolve all dependencies for <configuration>"));
      assertThat(e.getCause(), sameInstance((Throwable) failure));
    }
  }
 @Test
 public void testResolveAndGetFilesWithMissingDependenciesShouldThrowResolveException()
     throws IOException, ParseException {
   ModuleDescriptor moduleDescriptor = createAnonymousModuleDescriptor();
   prepareTestsThatRetrieveDependencies(moduleDescriptor);
   Exception failure = new Exception("broken");
   prepareResolveReportWithError(failure);
   ResolvedConfiguration configuration = ivyDependencyResolver.resolve(configurationStub);
   context.checking(
       new Expectations() {
         {
           allowing(configurationStub).getAllDependencies();
         }
       });
   try {
     configuration.getFiles(Specs.SATISFIES_ALL);
     fail();
   } catch (ResolveException e) {
     assertThat(
         e.getMessage(), startsWith("Could not resolve all dependencies for <configuration>"));
     assertThat(e.getCause(), sameInstance((Throwable) failure));
   }
 }
  @Test
  public void testResolveAndGetFilesWithDependencySubset() throws IOException, ParseException {
    prepareResolveReport();
    final ModuleDependency moduleDependencyDummy1 = context.mock(ModuleDependency.class, "dep1");
    final ModuleDependency moduleDependencyDummy2 = context.mock(ModuleDependency.class, "dep2");
    final SelfResolvingDependency selfResolvingDependencyDummy =
        context.mock(SelfResolvingDependency.class);
    final ResolvedDependency root = context.mock(ResolvedDependency.class, "root");
    final ResolvedDependency resolvedDependency1 =
        context.mock(ResolvedDependency.class, "resolved1");
    final ResolvedDependency resolvedDependency2 =
        context.mock(ResolvedDependency.class, "resolved2");
    ResolvedDependency resolvedDependency3 = context.mock(ResolvedDependency.class, "resolved3");
    final DependencySet dependencies = context.mock(DependencySet.class);
    final Map<Dependency, Set<ResolvedDependency>> firstLevelResolvedDependencies =
        new LinkedHashMap<Dependency, Set<ResolvedDependency>>();
    firstLevelResolvedDependencies.put(
        moduleDependencyDummy1, toSet(resolvedDependency1, resolvedDependency2));
    firstLevelResolvedDependencies.put(moduleDependencyDummy2, toSet(resolvedDependency3));

    context.checking(
        new Expectations() {
          {
            allowing(resolvedDependency1).getParentArtifacts(root);
            will(
                returnValue(
                    toSet(
                        createResolvedArtifact(
                            context,
                            "dep1parent",
                            "someType",
                            "someExtension",
                            new File("dep1parent")))));
            allowing(resolvedDependency1).getChildren();
            will(returnValue(emptySet()));
            allowing(resolvedDependency2).getParentArtifacts(root);
            will(
                returnValue(
                    toSet(
                        createResolvedArtifact(
                            context,
                            "dep2parent",
                            "someType",
                            "someExtension",
                            new File("dep2parent")))));
            allowing(resolvedDependency2).getChildren();
            will(returnValue(emptySet()));
            allowing(configurationStub).getAllDependencies();
            will(returnValue(dependencies));
            allowing(dependencies).withType(ModuleDependency.class);
            will(
                returnValue(
                    toDomainObjectSet(
                        ModuleDependency.class, moduleDependencyDummy1, moduleDependencyDummy2)));
            allowing(conversionResultStub).getFirstLevelResolvedDependencies();
            will(returnValue(firstLevelResolvedDependencies));
            allowing(conversionResultStub).getRoot();
            will(returnValue(root));
          }
        });

    ModuleDescriptor moduleDescriptor = createAnonymousModuleDescriptor();
    prepareTestsThatRetrieveDependencies(moduleDescriptor);

    ResolvedConfiguration resolvedConfig = ivyDependencyResolver.resolve(configurationStub);
    Set<File> actualFiles =
        resolvedConfig.getFiles(
            new Spec<Dependency>() {
              public boolean isSatisfiedBy(Dependency element) {
                return element == moduleDependencyDummy1 || element == selfResolvingDependencyDummy;
              }
            });
    assertThat(actualFiles, equalTo(toSet(new File("dep1parent"), new File("dep2parent"))));

    Set<ResolvedDependency> actualDeps =
        resolvedConfig.getFirstLevelModuleDependencies(
            new Spec<Dependency>() {
              public boolean isSatisfiedBy(Dependency element) {
                return element == moduleDependencyDummy1;
              }
            });
    assertThat(actualDeps, equalTo(toSet(resolvedDependency1, resolvedDependency2)));
  }
 public Set<File> getFiles(Spec<? super Dependency> dependencySpec) {
   Set<File> files = new LinkedHashSet<File>();
   files.addAll(selfResolvingFilesProvider.getFiles(dependencySpec));
   files.addAll(resolvedConfiguration.getFiles(dependencySpec));
   return files;
 }
 public Set<ResolvedArtifact> getResolvedArtifacts() {
   return resolvedConfiguration.getResolvedArtifacts();
 }
 public void rethrowFailure() throws GradleException {
   resolvedConfiguration.rethrowFailure();
 }
 public LenientConfiguration getLenientConfiguration() {
   return resolvedConfiguration.getLenientConfiguration();
 }
 public boolean hasError() {
   return resolvedConfiguration.hasError();
 }
 public Set<ResolvedDependency> getFirstLevelModuleDependencies(
     Spec<? super Dependency> dependencySpec) throws ResolveException {
   return resolvedConfiguration.getFirstLevelModuleDependencies(dependencySpec);
 }
 public Set<ResolvedDependency> getFirstLevelModuleDependencies() {
   return resolvedConfiguration.getFirstLevelModuleDependencies();
 }