def ivy

        when:
        manager.withIvy(action1)

        then:
        1 * action1.execute(_) >> { Ivy param ->
            ivy = param
            manager.withIvy(transformer)
        }
        1 * transformer.transform(_) >> { Ivy param ->
            assert param.is(ivy)
            manager.withIvy(action2)
        }
        1 * action2.execute(_) >> { Ivy param ->

        return ivyContextManager.withIvy(ivy -> {
            return delegate.parseMetaData(context, resource);
        });
    }

    @Override
    public ParseResult<T> parseMetaData(final DescriptorParseContext ivySettings, final File descriptorFile) throws MetaDataParseException {
        return ivyContextManager.withIvy(ivy -> {
            return delegate.parseMetaData(ivySettings, descriptorFile);

		if continueRV > 0 {
			withRev = continueRV
		}
		return withRev, nil
	}
	// Returns 0 if ResourceVersion is not specified.
	if len(opts.ResourceVersion) == 0 {
		return withRev, nil
	}
	parsedRV, err := s.versioner.ParseResourceVersion(opts.ResourceVersion)
	if err != nil {
		return withRev, apierrors.NewBadRequest(fmt.Sprintf("invalid resource version: %v", err))
	}

    private final ThreadLocal<Integer> depth = new ThreadLocal<>();

    @Override
    public void withIvy(final Action<? super Ivy> action) {
        withIvy(Transformers.toTransformer(action));
    }

    @Override
    public <T> T withIvy(Transformer<? extends T, ? super Ivy> action) {
        Integer currentDepth = depth.get();

        if (currentDepth != null) {

     */
    void withIvy(Action<? super Ivy> action);

    /**
     * Executes the given action against an Ivy instance and returns the result. Sets up the Ivy context before the action and cleans up at the end.
     *
     * <p>The Ivy instance of the calling thread is reused if the thread is already executing an action against an Ivy instance.
     */
    <T> T withIvy(Transformer<? extends T, ? super Ivy> action);

			getResp.Kvs[i] = nil
		}

		if withRev == 0 {
			wc.initialRev = getResp.Header.Revision
		}

		// no more results remain
		if !getResp.More {
			return nil
		}

		preparedKey = string(lastKey) + "\x00"
		if withRev == 0 {
			withRev = getResp.Header.Revision
			opts = append(opts, clientv3.WithRev(withRev))
		}
	}
}

func logWatchChannelErr(err error) {

        this.ivyContextManager = ivyContextManager;
    }

    @Override
    public void publish(final IvyNormalizedPublication publication, final IvyArtifactRepository repository) {
        ivyContextManager.withIvy(new Action<Ivy>() {
            @Override
            public void execute(Ivy ivy) {
                ivyPublisher.publish(publication, repository);
            }
        });
    }

		{
			name:        "all refs",
			claimStates: []string{withRef, withRef},
			expected:    false,
		},
		{
			name:        "stale & exists",
			claimStates: []string{stale, exists},
			expected:    true,
		},
		{
			name:        "stale & missing",
			claimStates: []string{stale, missing},
			expected:    true,
		},
		{
			name:        "withRef & stale",
			claimStates: []string{withRef, stale},

		t.Fatalf("Put failed: %v", err)
	}

	_, _, err = compact(ctx, client, 0, putResp1.Header.Revision)
	if err != nil {
		t.Fatalf("compact failed: %v", err)
	}

	obj, err := client.Get(ctx, "/somekey", clientv3.WithRev(putResp.Header.Revision))
	if err != etcdrpc.ErrCompacted {
		t.Errorf("Expecting ErrCompacted, but get=%v err=%v", obj, err)
	}
}

	if isRaceBuilder && (aSize > 1000 || bSize > 1000) {
		b.Skip("skipping on race builder")
	}
	b.Run("WithoutXY", func(b *testing.B) {
		runGCDExt(b, aSize, bSize, false)
	})
	b.Run("WithXY", func(b *testing.B) {
		runGCDExt(b, aSize, bSize, true)
	})
}

func runGCDExt(b *testing.B, aSize, bSize uint, calcXY bool) {
	b.StopTimer()
	var r = rand.New(rand.NewSource(1234))
	aa := randInt(r, aSize)