== Profile report

If you prefer not to use build scans, you can generate an HTML report in the
`build/reports/profile` directory of your root project. To generate this report,
use the `--profile` command-line option:

[listing.terminal]
----
$ gradle --profile <tasks>
----

Each profile report has a timestamp in its name to avoid overwriting existing ones.

				fmt.Fprintf(&buf, "%s: ", p.pos)
			}
		}
		buf.WriteString(p.msg)
	}
	return buf.String()
}

// report reports the error err, setting check.firstError if necessary.
func (err *error_) report() {
	if err.empty() {
		panic("no error")
	}

	// Cheap trick: Don't report errors with messages containing
	// "invalid operand" or "invalid type" as those tend to be

				targsList = [][]Type{targs}
				xlistList = [][]syntax.Expr{xlist}
				// Update x.expr so that we can record the partially instantiated function.
				x.expr = inst
			} else {
				// x was instantiated: we must record it here because we didn't
				// use the usual expression evaluators.
				check.record(&x)
			}
			resList = []*operand{&x}
		} else {

  /** Reallocate with memory tracking. */
  #define CU_REALLOC(x, y)        CU_realloc((x), (y), __LINE__, __FILE__)
  /** Generate report on tracked memory. */
  #define CU_CREATE_MEMORY_REPORT(x) CU_dump_memory_usage((x))
  /** Generate report on tracked memory (old macro). */
  #define CU_DUMP_MEMORY_USAGE(x) CU_dump_memory_usage((x))
#else   /* MEMTRACE */
  /** Standard calloc() if MEMTRACE not defined. */

				targsList = [][]Type{targs}
				xlistList = [][]ast.Expr{xlist}
				// Update x.expr so that we can record the partially instantiated function.
				x.expr = ix.Orig
			} else {
				// x was instantiated: we must record it here because we didn't
				// use the usual expression evaluators.
				check.record(&x)
			}
			resList = []*operand{&x}
		} else {

        def repo1 = mavenHttpRepo("repo1")
        def repo2 = mavenHttpRepo("repo2")

        given:
        buildFile << """
repositories.clear() // Do not use default repo
repositories {
    maven {
        url "${repo1.uri}"
        artifactUrls "${repo2.uri}"
    }
}

dependencies {

        given:
        def repo1 = ivyHttpRepo("repo1")
        def repo2 = mavenHttpRepo("repo2")
        def projectAInRepo1 = repo1.module('group', 'projectA', '1.2')
        def projectAInRepo2 = repo2.module('group', 'projectA', '1.2').publish()
        def projectB = repo1.module('group', 'projectB', '1.3').publish()

        and:
        buildFile << """
repositories {

    }

    void "cache entries are segregated between different repositories"() {
        given:
        def repo1 = ivyHttpRepo('ivy-repo-a')
        def module1 = repo1.module('org.gradle', 'testproject', '1.0').publish()
        def repo2 = ivyHttpRepo('ivy-repo-b')
        def module2 = repo2.module('org.gradle', 'testproject', '1.0').publishWithChangedContent()

        and:
        createDirs("a", "b")

	for i, step := range steps {
		secondsToAdvance := step.secondsElapsed
		if i > 0 {
			secondsToAdvance -= steps[i-1].secondsElapsed
		}
		fakeClock.Step(time.Duration(secondsToAdvance) * time.Second)

		// Record all droppeded requests and recompute retryAfter.
		for r := 0; r < step.droppedRequests; r++ {
			tracker.RecordDroppedRequest("pl")
		}
		if retryAfter := tracker.GetRetryAfter("pl"); retryAfter != step.retryAfter {

        publishLocalTasks.size() == 1
    }

    def "tasks are created for compatible publication / repo"() {
        given:
        publishing.publications.create("test", MavenPublication)

        when:
        def repo1 = publishing.repositories.maven { url "foo" }
        def repo2 = publishing.repositories.maven { url "foo"; name "other" }
        publishing.repositories.ivy {}

        then: