launcher.setJvmArguments("-Dorg.gradle.workers.max=12")
        }

        then:
        result.standardOutput.contains("max workers: 12")
    }

    def "command-line arguments take precedence over system properties"() {
        when:
        def result = withBuild { BuildLauncher launcher ->
            launcher.withArguments("-Dorg.gradle.workers.max=4", "--max-workers=12")
        }

        then:

	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgActiveWorkerStat(b *testing.B) {
	v := ActiveWorkerStat{}

	left, err := v2.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) != 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
	if !reflect.DeepEqual(v, v2) {
		t.Errorf("MSS: %v != %v", v, v2)
	}
}

// license that can be found in the LICENSE file.

// Test the 'for range' construct ranging over integers.

package main

func testint1() {
	bad := false
	j := 0
	for i := range int(4) {
		if i != j {
			println("range var", i, "want", j)
			bad = true
		}
		j++
	}
	if j != 4 {
		println("wrong count ranging over 4:", j)
		bad = true
	}
	if bad {
		panic("testint1")
	}
}

	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgBucketReplicationResyncStatus(b *testing.B) {

	// Get expected limit.
	limitRe := regexp.MustCompile(`nosplit stack over (\d+) byte limit`)
	m := limitRe.FindStringSubmatch(out)
	if m == nil {
		t.Fatalf("no overflow errors in output")
	}
	limit, _ := strconv.Atoi(m[1])

	wantMap := map[string]string{
		"main.startSelf": fmt.Sprintf(
			`main.startSelf<0>
    grows 1008 bytes
    %d bytes over limit
`, 1008-limit),
		"main.startChain": fmt.Sprintf(

	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgMetricDescription(b *testing.B) {
	v := MetricDescription{}

	{"copy", vgradGreen(90), fillAlpha(255), Over, color.RGBA{88, 48, 0, 255}},
	{"copySrc", vgradGreen(90), fillAlpha(255), Src, color.RGBA{0, 48, 0, 90}},
	{"copyAlpha", vgradGreen(90), fillAlpha(192), Over, color.RGBA{100, 36, 0, 255}},
	{"copyAlphaSrc", vgradGreen(90), fillAlpha(192), Src, color.RGBA{0, 36, 0, 68}},
	{"copyNil", vgradGreen(90), nil, Over, color.RGBA{88, 48, 0, 255}},

            .add("in", "the", "quick", "jumped", "over", "a")
            .build();
    assertThat(set).containsExactly("a", "in", "the", "over", "quick", "jumped").inOrder();
  }

  public void testExplicit_ordering_dupes() {
    SortedSet<String> set =
        ImmutableSortedSet.orderedBy(STRING_LENGTH)
            .add("in", "the", "quick", "brown", "fox", "jumped", "over", "a", "lazy", "dog")
            .build();

import spock.lang.Issue

class DynamicMethodLookupIntegrationTest extends AbstractIntegrationSpec {
    @Issue("GRADLE-3460")
    def "extension configuration method is preferred over property with closure value"() {
        given:
        buildFile """
class ContactExtension {
    String prop
}

class ContactPlugin implements Plugin<Project> {
    public void apply(Project project) {