configurations { compile }

            dependencies {
                compile 'org.test:projectA:1.0'
            }
        """
        resolve.prepare()
    }

    def "produces sensible error when bad code is supplied in component metadata rule" () {
        def lines = buildFile.readLines().size()
        buildFile << """
            class WrongRule implements ComponentMetadataRule {

  @Override
  public boolean equals(@CheckForNull Object object) {
    return delegate().equals(object);
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  /**
   * A sensible definition of {@link #equals(Object)} in terms of {@link #getKey()} and {@link
   * #getValue()}. If you override either of these methods, you may wish to override {@link
   * #equals(Object)} to forward to this implementation.
   *

  @Override
  protected abstract SortedMultiset<E> delegate();

  @Override
  public SortedSet<E> elementSet() {
    return (SortedSet<E>) super.elementSet();
  }

  /**
   * A sensible implementation of {@link SortedMultiset#elementSet} in terms of the following
   * methods: {@link SortedMultiset#clear}, {@link SortedMultiset#comparator}, {@link

        ivy.expectArtifact(moduleName).hasAttributes("jar", "jar", ["compile", "runtime"])
        module.ivyFile.assertDoesNotExist()
    }

    def "produces sensible error when withXML fails"() {
        when:
        buildFile << """
            publishing {
                publications {
                    ivy {
                        descriptor.withXml {

                            url = uri("$gitRepo")
                            ${repoDef}
                        }
                    }
                }
            }
        """
    }

    def 'emits sensible error when bad code is in vcsMappings block'() {
        settingsFile << """
            sourceControl {
                vcsMappings {
                    all { details ->
                        foo()

  @Override
  public boolean equals(@CheckForNull Object object) {
    return delegate().equals(object);
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  /**
   * A sensible definition of {@link #equals(Object)} in terms of {@link #getKey()} and {@link
   * #getValue()}. If you override either of these methods, you may wish to override {@link
   * #equals(Object)} to forward to this implementation.
   *

 */

package org.gradle.api.internal.artifacts.ivyservice

import org.gradle.api.internal.component.ArtifactType
import spock.lang.Specification

class ArtifactTypeTest extends Specification {
    def "have sensible toString values"() {
        expect:
        ArtifactType.SOURCES.toString() == "'sources' artifacts"
        ArtifactType.JAVADOC.toString() == "'javadoc' artifacts"

 * limitations under the License.
 */

package org.gradle.internal.serialize;

import com.google.common.base.Objects;

/**
 * This abstract class provide a sensible default implementation for {@code Serializer} equality. This equality
 * implementation is required to enable cache instance reuse within the same Gradle runtime. Serializers are used

                <td><literal>'lib'</literal></td>
            </tr>
            <tr>
                <td>deploymentDescriptor</td>
                <td>A deployment descriptor initialized with sensible defaults</td>
            </tr>
            <tr>
                <td>generateDeploymentDescriptor</td>
                <td><literal>true</literal></td>
            </tr>
        </table>
    </section>

                    ${toolChain.buildScriptConfig}
                }
            }
        """
    }

    def "toolchain is not available when the discovered swift executable does not return sensible output"() {
        def scriptDir = testDirectory.createDir("scriptDir")
        def script = scriptDir.createFile("swiftc")
        script << """
            #!/bin/sh
            echo "foo"
        """