}

  public void testGetAndAdd() {
    Count holder = new Count(20);
    assertEquals(20, holder.get());
    holder.add(1);
    assertEquals(21, holder.get());
  }

  public void testAddAndGet() {
    Count holder = new Count(20);
    assertEquals(21, holder.addAndGet(1));
  }

  public void testGetAndSet() {
    Count holder = new Count(10);
    assertEquals(10, holder.getAndSet(20));
    assertEquals(20, holder.get());

	}
}

func TestValidateLeaseSpecUpdate(t *testing.T) {
	holder := "holder"
	leaseDuration := int32(0)
	leaseTransitions := int32(-1)
	lease := &coordination.Lease{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "holder",
			Namespace: "holder-namespace",
		},
		Spec: coordination.LeaseSpec{
			HolderIdentity:       &holder,
			LeaseDurationSeconds: &leaseDuration,
			LeaseTransitions:     &leaseTransitions,

        osMemoryInfo.freeMemory = MemoryAmount.of('4g').bytes
        def memoryManager = newMemoryManager()

        and:
        def holder = Mock(MemoryHolder)
        memoryManager.addMemoryHolder(holder)

        when:
        memoryManager.requestFreeMemory(0)

        then:
        0 * holder.attemptToRelease(_)

        cleanup:
        memoryManager.stop()
    }

    /**
     * Register a memory resource holder.
     *
     * @param holder The memory resource holder to register
     */
    void addMemoryHolder(MemoryHolder holder);

    /**
     * Unregister a memory resource holder.
     *
     * @param holder The memory resource holder to unregister
     */
    void removeMemoryHolder(MemoryHolder holder);

    /**
     * Request an amount of free system memory.

    final Map<Path, Holder> modelByPath = new ConcurrentHashMap<>();

    final Map<GAKey, Holder> modelByGA = new ConcurrentHashMap<>();

    public static class Holder {
        private volatile boolean set;
        private volatile Model model;

        Holder() {}

        Holder(Model model) {
            this.model = Objects.requireNonNull(model);

    final Map<Path, Holder> modelByPath = new ConcurrentHashMap<>();

    final Map<GAKey, Holder> modelByGA = new ConcurrentHashMap<>();

    public static class Holder {
        private volatile boolean set;
        private volatile Model model;

        Holder() {}

        Holder(Model model) {
            this.model = Objects.requireNonNull(model);

Copyright <YEAR> <COPYRIGHT HOLDER>

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the

	// for this example, this block should never run
	if _, ok := any(m).(SomeInterface); ok {
		var dst SomeInterface
		_, _ = dst.(T)
		return dst.(T)
	}

	return m
}

type holder struct{}

func main() {
	X[holder]()

    private final Queue<Holder> changeQueue = new LinkedBlockingQueue() // unprocessed changes

    private final ManagedExecutor executor
    private boolean stop = false

    private AssertionError timeoutError

    // wrapper object for the queue, to enable a null sentinel
    private class Holder {
        final value
        Holder(value) {
            this.value = value
        }
    }

class DynamicGroovyBean {
    
    private holder = null;
    
    Map called = [:]
    
    def propertyMissing(String name) {
        if (name == "foo") {
            return holder;
        } else {
            throw new MissingPropertyException(name, getClass())
        }
    }

    def propertyMissing(String name, value) {
        if (name == "foo") {
            holder = value;
        } else {