and:
        def twoDaysAgo = daysAgo(2).get()
        cacheConfigurations.createdResources.removeUnusedEntriesOlderThan.set(twoDaysAgo)
        cacheConfigurations.downloadedResources.removeUnusedEntriesOlderThan.set(twoDaysAgo)
        cacheConfigurations.releasedWrappers.removeUnusedEntriesOlderThan.set(twoDaysAgo)
        cacheConfigurations.snapshotWrappers.removeUnusedEntriesOlderThan.set(twoDaysAgo)

        then:

            property.set(provider)

            assert property.get() == 1
            assert property.get() == 2

            property.finalizeValue()

            assert counter == 3 // is eager
            assert property.get() == 3

            counter = 45
            assert property.get() == 3

            property.set(12)
        """

        when:
        fails()

                text.set('Hello')
            }
            tasks.register('myTask2', MyTask) {
                text.set('World')
            }

            tasks.register('combined', MyTask) {
                text.set(providers.zip(
                    tasks.named('myTask1').map { t -> t.text.get() },
                    tasks.named('myTask2').map { t -> t.text.get() }) { h, w ->
                    "\$h, \$w!"

    }
  }

  /** get returns the last value set at index */
  public void testGetSet() {
    AtomicDoubleArray aa = new AtomicDoubleArray(VALUES.length);
    for (int i = 0; i < VALUES.length; i++) {
      assertBitEquals(0.0, aa.get(i));
      aa.set(i, VALUES[i]);
      assertBitEquals(VALUES[i], aa.get(i));
      aa.set(i, -3.0);
      assertBitEquals(-3.0, aa.get(i));
    }
  }

        }
      } else {
        // set on the future completed
        assertFalse(cancellationSuccess.get());
        assertTrue(setFutureSetSuccess.get());
        assertTrue(setFutureCompletionSuccess.get());
      }
      // reset for next iteration
      setFutureSetSuccess.set(false);
      setFutureCompletionSuccess.set(false);
      cancellationSuccess.set(false);
      finalResults.clear();
    }

// 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
}

    #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" ) )

    SettableFuture<Integer> future = SettableFuture.create();
    assertTrue(future.set(42));
    // Later attempts to set the future should return false.
    assertFalse(future.set(23));
    assertFalse(future.setException(new Exception("bar")));
    assertFalse(future.setFuture(SettableFuture.<Integer>create()));
    // Check that the future has been set properly.
    assertTrue(future.isDone());
    assertFalse(future.isCancelled());

		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 {

                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());