expectGetMetadata()
                expectGetArtifact(classifier: 'classy')
            }
        }
        succeeds "checkDep"

        then:
        resolve.expectGraph {
            root(':', ':test:') {
                module("org:foo:1.0") {
                    module("org:bar:1.0") {
                        artifact(classifier: 'classy')
                    }
                }
            }
        }

        var psiClass = PsiTreeUtil.getContextOfType(useSitePosition, PsiClass::class.java, false)
        while (psiClass != null && psiClass.name == null || psiClass is PsiTypeParameter) {
            psiClass = PsiTreeUtil.getContextOfType(psiClass, PsiClass::class.java, true)
        }
        if (psiClass != null) {
            val qualifiedName = psiClass.qualifiedName

     * Specifies the paths where javadoc will look for referenced classes (.class files)
     * -- these are the documented classes plus any classes referenced by those classes.
     * The classpathlist can contain multiple paths by separating them with a semicolon (;).
     * The Javadoc tool will search in all subdirectories of the specified paths.
     * Follow the instructions in class path documentation for specifying classpathlist.
     * <p>

        m1.getArtifact(type: '', ext: '', classifier: 'classy').expectGet()

        run 'show'

        then:
        outputContains("files: [test-1.0, test-1.0, test-1.0-classy]")
        outputContains("display-names: [test-1.0 (org:test:1.0), test-1.0 (org:test:1.0), test-1.0-classy (org:test:1.0)]")
        outputContains("ids: [test-1.0 (org:test:1.0), test-1.0 (org:test:1.0), test-1.0-classy (org:test:1.0)]")

import spock.lang.Specification

class TestResultTest extends Specification {
    def canOrderResultsByClassNameAndTestName() {
        ClassTestResults class1 = Mock()
        _ * class1.name >> 'name'
        ClassTestResults class2 = Mock()
        _ * class2.name >> 'a'
        ClassTestResults class3 = Mock()
        _ * class3.name >> 'z'

        TestResult result = new TestResult('name', 0, class1)

    /**
     * Checks if entity contains annotation with specified [classId].
     *
     * The semantic is equivalent to
     * ```
     * annotationsList.hasAnnotation(classId) == annotationsList.annotations.any { it.classId == classId }
     * ```
     * @param classId [ClassId] to search
     */
    public operator fun contains(classId: ClassId): Boolean

  }

  /** Global cache of classes to their flattened hierarchy of supertypes. */
  private static final LoadingCache<Class<?>, ImmutableSet<Class<?>>> flattenHierarchyCache =
      CacheBuilder.newBuilder()
          .weakKeys()
          .build(
              new CacheLoader<Class<?>, ImmutableSet<Class<?>>>() {
                // <Class<?>> is actually needed to compile

        child.publish()

        buildFile << """
repositories {
    maven { url '${mavenRepo.uri}' }
}
configurations { compile }
dependencies { compile 'org:child:1.0' }
task libs { doLast { assert configurations.compile.files*.name == ['child-1.0.jar', 'child_dep-1.7.jar', 'typed_dep-1.8.bar', 'classified_dep-1.9-classy.jar', 'fq_dep-2.1-classy.bar'] } }
"""

        expect:
        succeeds 'libs'

dependencies {
    compile 'group:projectA:1.2@jar'
    compile 'group:projectB:1.2:classy@jar'
}
task retrieve(type: Sync) {
    into 'libs'
    from configurations.compile
}
"""

        when:
        projectA.pom.expectGet()
        projectA.artifact.expectGet()
        projectB.pom.expectGet()
        projectB.artifact(classifier: 'classy').expectGet()

        then:
        succeeds('retrieve')

				classes[j].upperBound = x
				classes[j].lowerBound = x * math.Max(0, 1.25*rands.Float64()-1)
				classes[j].target = classes[j].lowerBound + rands.Float64()
				lowSum += classes[j].lowerBound
				highSum += classes[j].upperBound
			})
		default:
			style = "not-set-by-bounds"
			for j := 0; j < probLen; j++ {
				x := math.Max(0, rands.Float64()*5-1)
				classes[j].lowerBound = x