{
			description:     "when removing all conditions",
			pvc:             pvc.DeepCopy(),
			newConditions:   []v1.PersistentVolumeClaimCondition{},
			finalConditions: []v1.PersistentVolumeClaimCondition{},
		},
		{
			description: "adding new condition",
			pvc:         pvc.DeepCopy(),
			newConditions: []v1.PersistentVolumeClaimCondition{
				{
					Type:   v1.PersistentVolumeClaimFileSystemResizePending,

		for i := range node.Status.Conditions {
			if node.Status.Conditions[i].Type == v1.NodeMemoryPressure {
				condition = &node.Status.Conditions[i]
			}
		}

		newCondition := false
		// If the NodeMemoryPressure condition doesn't exist, create one
		if condition == nil {
			condition = &v1.NodeCondition{
				Type:   v1.NodeMemoryPressure,
				Status: v1.ConditionUnknown,
			}

import java.util.concurrent.locks.ReentrantLock

class TestManagedExecutor extends AbstractExecutorService implements ManagedExecutor {
    private final Lock lock = new ReentrantLock()
    private final Condition condition = lock.newCondition()
    private int count
    private final TestExecutor executor;

    TestManagedExecutor(TestExecutor executor) {
        this.executor = executor
    }

    void execute(Runnable command) {

    private int requestsStarted;

    ChainingHttpHandler(Lock lock, int timeoutMs, AtomicInteger counter, WaitPrecondition first) {
        this.lock = lock;
        this.condition = lock.newCondition();
        this.timeoutMs = timeoutMs;
        this.counter = counter;
        this.last = first;
    }

    public <T extends TrackingHttpHandler> T addHandler(HandlerFactory<T> factory) {
        lock.lock();

    private enum State {RUNNING, STOPPING, STOPPED}

    private final String displayName;
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private final Map<Thread, Integer> usages = new HashMap<>();
    private State state = State.RUNNING;

    public ServiceLifecycle(String displayName) {
        this.displayName = displayName;
    }

import java.util.concurrent.locks.Lock
import java.util.concurrent.locks.ReentrantLock

class TestExecutor implements Executor {
    private final Lock lock = new ReentrantLock()
    private final Condition condition = lock.newCondition()
    private final Set<Thread> threads = new HashSet<Thread>()
    private final TestLogger logger
    private Thread owner
    private Throwable failure
    private int threadNum

    SendPartialResponseThenBlock(Lock lock, Duration timeout, WaitPrecondition precondition, byte[] content) {
        this.lock = lock;
        this.timeout = timeout;
        condition = lock.newCondition();
        this.precondition = precondition;
        this.content = content;
    }

    @Override
    public void writeTo(int requestId, HttpExchange exchange) throws IOException {

    }

    private static abstract class CommandQueue<C extends Message, H> implements Stoppable {
        private final Lock lock = new ReentrantLock();
        private final Condition condition = lock.newCondition();
        protected final LinkedList<C> queue = new LinkedList<C>();
        private final String name;
        private ManagedExecutor executor;
        private boolean removed;

class ConcurrentTestUtil extends ExternalResource {
    private static final Logger LOG = LoggerFactory.getLogger(ConcurrentTestUtil.class)

    private Lock lock = new ReentrantLock()
    private Condition threadsChanged = lock.newCondition()
    private Set<TestThread> threads = [] as Set
    private Closure failureHandler
    private List<Throwable> failures = []
    private timeout = 5000

    ConcurrentTestUtil() {}

			// OR if the number of failed jobs increased since the last syncJob
			jobCtx.finishedCondition = newCondition(batch.JobFailed, v1.ConditionTrue, batch.JobReasonBackoffLimitExceeded, "Job has reached the specified backoff limit", jm.clock.Now())
		} else if jm.pastActiveDeadline(&job) {