#set ( $types = { } )
    #set ( $imports = $class.getClass().forName("java.util.TreeSet").newInstance() )
    #set ( $dummy = $imports.add( "java.io.Serializable" ) )
    #set ( $dummy = $imports.add( "java.util.AbstractList" ) )
    #set ( $dummy = $imports.add( "java.util.Collections" ) )
    #set ( $dummy = $imports.add( "java.util.HashMap" ) )
    #set ( $dummy = $imports.add( "java.util.List" ) )

// from multiple goroutines via the Get and Set methods.
type Lockable[T any] struct {
	x  T
	mu sync.Mutex
}

// Get returns the value stored in a Lockable.
func (l *Lockable[T]) get() T {
	l.mu.Lock()
	defer l.mu.Unlock()
	return l.x
}

// set sets the value in a Lockable.
func (l *Lockable[T]) set(v T) {
	l.mu.Lock()
	defer l.mu.Unlock()
	l.x = v
}

		if set, err = om.setsLister.StatefulSets(set.Namespace).Get(set.Name); err != nil {
			t.Errorf(onPolicy("Could not get scaled up set: %v", err))
		}
		if set.Status.Replicas != 3 {
			t.Errorf(onPolicy("set.Status.Replicas = %v; want 3", set.Status.Replicas))
		}
		*set.Spec.Replicas = 2
		if err := scaleDownStatefulSetController(logger, set, ssc, spc, om); err != nil {

    @Test
    fun `can initialize extra property via delegate provider`() {

        val extra = mock<ExtraPropertiesExtension> {
            on { get("property") } doReturn 42
        }

        val property by extra(42)

        // property is set eagerly
        verify(extra).set("property", 42)

        // And to prove the type is inferred correctly
        use(property)
    }

    @Test

                QueryBuilder builder = chain.execute(context, query, boost);
                assertTrue(called.get());
                assertTrue(calledFirst.get());
                return builder;
            }
        });
        queryBuilder = queryProcessor.execute(context, query, 1.0f);
        assertTrue(called.get());
        assertTrue(calledFirst.get());
        assertTrue(calledSecond.get());

// tag::set-prop[]
// Setting a property
val simpleMessageProperty: Property<String> = project.objects.property(String::class)
simpleMessageProperty.set("Hello, World from a Property!")
// Accessing a property
println(simpleMessageProperty.get())
// end::set-prop[]

// tag::set-prov[]
// Setting a provider
val simpleMessageProvider: Provider<String> = project.providers.provider { "Hello, World from a Provider!" }
// Accessing a provider

def provider = providers.provider { [++counter, ++counter] }

def property = objects.listProperty(Integer)
property.set(provider)

assert property.get() == [1, 2]
assert property.get() == [3, 4]
property.finalizeValue()
assert property.get() == [5, 6]
assert property.get() == [5, 6]

property.set([1])
"""

        when:
        fails()

        then:

// tag::set-property[]
ant.buildDir = buildDir
ant.properties.buildDir = buildDir
ant.properties['buildDir'] = buildDir
ant.property(name: 'buildDir', location: buildDir)
// end::set-property[]

ant.importBuild 'build.xml'

// tag::get-property[]
println ant.antProp
println ant.properties.antProp
println ant.properties['antProp']
// end::get-property[]

// tag::set-reference[]
ant.path(id: 'classpath', location: 'libs')

	tm := typemap.NewTypeMap()
	typemap.Set(tm, 1)
	typemap.Set(tm, int32(2))
	typemap.Set(tm, "old")
	typemap.Set(tm, "string")
	typemap.Set(tm, TestStruct{Field: "inner"})
	typemap.Set(tm, &TestStruct{Field: "pointer"})
	typemap.Set[TestInterface[string]](tm, TestStruct{Field: "interface"})

	assert.Equal(t, typemap.Get[int](tm), ptr.Of(1))
	assert.Equal(t, typemap.Get[int32](tm), ptr.Of(int32(2)))

#set ( $String = $model.getClass().forName("java.lang.String") )
#set ( $Comparator = $model.getClass().forName("java.util.Comparator") )
#set ( $LinkedHashSet = $model.getClass().forName("java.util.LinkedHashSet") )
#set ( $HashMap = $model.getClass().forName("java.util.HashMap") )
#set ( $TreeSet = $model.getClass().forName("java.util.TreeSet") )