def foo = tasks.create("foo", SomeTask)
            def bar = tasks.register("bar") { println "Create :bar" }
            def baz = tasks.create("baz", SomeTask)
            def fizz = tasks.create("fizz", SomeTask)
            def fuzz = tasks.create("fuzz", SomeTask)

            tasks.withType(SomeTask).configureEach { task ->
                println "Configuring " + task.name
                bar.get()
            }

            public class JavaClass {}
        """
        file("buildSrc/src/main/groovy/fizz/buzz/GroovyClass.groovy") << """
            package fizz.buzz;
            class GroovyClass {}
        """

        file("buildSrc/src/main/groovy/foo.gradle") << """
            import foo.bar.JavaClass
            import fizz.buzz.GroovyClass
            println JavaClass
            println GroovyClass

					NodeSelector: map[string]string{
						"foo":  "bar",
						"fizz": "buzz",
					},
				},
			},
			pod:         newSchedulingValidPod("pod-with-different-key-value-node-selector", map[string]string{"foo": "bar"}, nil),
			expectError: false,
			expectedPod: newSchedulingValidPod("pod-with-different-key-value-node-selector", map[string]string{"foo": "bar", "fizz": "buzz"}, nil),
		},
		{

        registry.register("foo") { it.unmanaged(String, "bar") { "foo" } }
            .register("bar") { it.unmanaged(String, "fizz") { "bar" } }
            .registerInstance("fizz", "fizz")
            .mutate { it.path("fizz").descriptor("fizz mutator").type(String).action("buzz", ModelType.of(String), {}) }
            .registerInstance("buzz", "buzz")

                foo:
                - bar: baz
                  val: newBazValue
            `),
			RootOldObject: mustUnstructured(`
                foo:
                - bar: fizz
                  val: fizzValue
                - bar: baz
                  val: bazValue
            `),
			Schema: mustSchema(`
                properties:
                  foo:

                @Model
                String second() {
                    "bar"
                }

                @Model
                String third(@Path("first") String first) {
                    "fizz"
                }

                @Mutate
                void connectTasksToFirst(ModelMap<Task> tasks, @Path("first") String first) {
                }
            }

            apply type: Rules

            tasks.register<PrintLn>("ok") {
                message.set(zipped)
            }
        """

        when:
        configurationCacheRun("ok", "-DmessagePrefix=fizz", "-DmessageSuffix=buzz")

        then:
        output.count("fizz buzz!") == 1
        configurationCache.assertStateStored()

        when:
        configurationCacheRun("ok", "-DmessagePrefix=foo", "-DmessageSuffix=bar")

        then:

        def project = new ProjectWithRuntimeClasspathNormalization(Api.RUNTIME)
        project.propertiesFileInDir.setContent('''
            foo=bar
            bar=baz
            fizz=fuzz
        '''.stripIndent())

        when:
        succeeds project.customTask
        then:
        executedAndNotSkipped(project.customTask)

        when:
        succeeds project.customTask

				return nil
			})

			// check we can patch items
			var patchedCfg config.Config
			if _, err := store.(*Client).Patch(*cfg, func(cfg config.Config) (config.Config, types.PatchType) {
				cfg.Annotations["fizz"] = "buzz"
				patchedCfg = cfg
				return cfg, types.JSONPatchType
			}); err != nil {
				t.Errorf("unexpected err in Patch: %v", err)
			}
			// validate it is updated

	m1.Add("z", 2)
	m.Set("map2", &m2)
	for i := 0; i < 9; i++ {
		m2.Add(strconv.Itoa(i), int64(i))
	}
	var s1, s2 String
	m.Set("str1", &s1)
	s1.Set("hello, world!")
	m.Set("str2", &s2)
	s2.Set("fizz buzz")
	b.ResetTimer()

	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_ = m.String()
	}
}

func BenchmarkRealworldExpvarUsage(b *testing.B) {
	var (
		bytesSent Int
		bytesRead Int