if lenientErr != nil {
			// Lenient decoding failed with the current version, return the
			// original strict error.
			return nil, fmt.Errorf("failed lenient decoding: %v", err)
		}
		// Continue with the v1beta1 object that was decoded leniently, but emit a warning.
		klog.InfoS("Using lenient decoding as strict decoding failed", "err", err)
	}

        } finally {
            hasReceived = true;
        }
    }

    /**
     * Treat the connection as probably broken, and leniently handle failures writing outgoing messages.
     */
    public void markSuspect() {
        suspect = true;
    }

    @Override
    public void stop() {

        succeeds "validate"
    }

    @ToBeFixedForConfigurationCache(because = "task uses Configuration API")

        description    | provider
        ''             | Providers.notDefined()
        ' in Callable' | { -> Providers.notDefined() }
    }

    def 'ignores absent Provider#description when resolving leniently'() {
        def collection = factory.resolvingLeniently(provider)

        expect:
        collection.files.empty

        where:
        description    | provider

		if lenientErr != nil {
			// Lenient decoding failed with the current version, return the
			// original strict error.
			return nil, fmt.Errorf("failed lenient decoding: %v", err)
		}

		// Continue with the v1alpha1 object that was decoded leniently, but emit a warning.
		o.logger.Info("Using lenient decoding as strict decoding failed", "err", err)
	}

        testServices.assertions.assertEquals(
            expectedResult,
            type1.isEqualTo(type2, KaSubtypingErrorTypePolicy.LENIENT),
        ) {
            "Expected `$type1` and `$type2` to be ${if (!expectedResult) "un" else ""}equal with error type leniency (`$resultDirective`)."
        }
    }
}

abstract class AbstractSubtypingTest : AbstractSemanticSubtypingTest() {

        // `NewKotlinTypeCheckerImpl` is inconsistent with its error type leniency: `isSubtypeOf` is lenient by default while `equalTypes`
        // isn't. Hence, even without a `LENIENT` policy, we need to wrap `typeChecker` to achieve consistent strictness.
        return IsErrorTypeEqualToAnythingTypeChecker(typeChecker, errorTypePolicy == KaSubtypingErrorTypePolicy.LENIENT)
    }

        super(taskDependencyFactory);
        this.resultProvider = resultProvider;
        this.lenient = lenient;
        this.resolutionHost = resolutionHost;
    }

    public ResolutionHost getResolutionHost() {
        return resolutionHost;
    }

    public boolean isLenient() {
        return lenient;
    }

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {

         *
         * When set to <code>true</code>, this view will resolve as many artifacts and/or files as possible
         * collecting any failures.
         *
         * When set to <code>false</code>, any failures will be propagated as exceptions when the view is resolved.
         */
        ViewConfiguration lenient(boolean lenient);

        /**

            return lenient;
        }

        @Override
        public void setLenient(boolean lenient) {
            this.lenient = lenient;
        }

        // TODO: Deprecate this in favor of setLenient(Boolean)
        @Override
        public ArtifactView.ViewConfiguration lenient(boolean lenient) {
            this.lenient = lenient;
            return this;
        }