/*
     * @see org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable#contextualize(org.codehaus.plexus.context.Context)
     */

    @Override
    public void contextualize(Context context) throws ContextException {
        container = (PlexusContainer) context.get(PlexusConstants.PLEXUS_KEY);
    }

        RequestTrace parentTrace = new RequestTrace("parent-context", null, "parent-data");
        RequestTrace childTrace = new RequestTrace("child-context", parentTrace, "child-data");

        assertEquals("parent-context", parentTrace.context());
        assertNull(parentTrace.parent());
        assertEquals("parent-data", parentTrace.data());

        assertEquals("child-context", childTrace.context());

    protected void lookup(EncryptContext context) throws Exception {
        if (context.goals == null) {
            super.lookup(context);
            context.goals = context.lookup.lookupMap(Goal.class);
        }
    }

    @Override
    protected int execute(EncryptContext context) throws Exception {
        try {
            context.header = new ArrayList<>();
            context.style = new AttributedStyle();

    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withDependencies {
                removeAll { groupsToRemove.contains(it.group) }
            }
        }
    }
}


abstract class KeepDependenciesByNameRule @Inject constructor(
    private val moduleToKeep: Set<String>
) : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {

    protected void lookup(UpgradeContext context) throws Exception {
        if (context.goals == null) {
            super.lookup(context);
            context.goals = context.lookup.lookupMap(Goal.class);
        }
    }

    @Override
    protected int execute(UpgradeContext context) throws Exception {
        try {
            context.header = new ArrayList<>();
            context.style = new AttributedStyle();

type BatchJobKeyRotateEncryption struct {
	Type       BatchKeyRotationType `yaml:"type" json:"type"`
	Key        string               `yaml:"key" json:"key"`
	Context    string               `yaml:"context" json:"context"`
	kmsContext kms.Context          `msg:"-"`
}

// Validate validates input key rotation encryption options.
func (e BatchJobKeyRotateEncryption) Validate() error {
	if e.Type != sses3 && e.Type != ssekms {

            UpgradeContext context = createMockContext(options);

            assertFalse(strategy.isApplicable(context), "Strategy should not be applicable when --model is false");
        }

        @Test
        @DisplayName("should handle all options disabled")
        void shouldHandleAllOptionsDisabled() {
            UpgradeContext context = TestUtils.createMockContext(TestUtils.createOptions(

	h1 := func(payload []byte) ([]byte, *RemoteErr) {
		gotCall <- struct{}{}
		<-cleanReqs
		return nil, nil
	}
	// 2: Also block, but with streaming.
	h2 := StreamHandler{
		Handle: func(ctx context.Context, payload []byte, request <-chan []byte, resp chan<- []byte) *RemoteErr {
			gotCall <- struct{}{}
			select {
			case <-ctx.Done():
				gotCall <- struct{}{}
			case <-cleanReqs:

}

func (S Tracer) Warn(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Warn(ctx, s, i...)
}

func (S Tracer) Error(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Error(ctx, s, i...)
}

func (S Tracer) Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error) {
	S.Logger.Trace(ctx, begin, fc, err)
	S.Test(ctx, begin, fc, err)

    }

    @Override
    public List<Profile> getActiveProfiles(
            Collection<Profile> profiles, ProfileActivationContext context, ModelProblemCollector problems) {
        Collection<String> activatedIds = new HashSet<>(context.getActiveProfileIds());
        Collection<String> deactivatedIds = new HashSet<>(context.getInactiveProfileIds());

        List<Profile> activeProfiles = new ArrayList<>(profiles.size());