public StreamAction(ZipArchiveOutputStream zipOutStr, String encoding) {
            this.zipOutStr = zipOutStr;
            if (encoding != null) {
                this.zipOutStr.setEncoding(encoding);
            }
        }

        @Override
        public void processFile(FileCopyDetailsInternal details) {
            if (details.isDirectory()) {
                visitDir(details);

                .withPathSensitivity(PathSensitivity.NAME_ONLY);

            StandardJavadocDocletOptions options = (StandardJavadocDocletOptions) task.getOptions();
            options.setEncoding("utf-8");
            options.setDocEncoding("utf-8");
            options.setCharSet("utf-8");

            options.addBooleanOption("-allow-script-in-comments", true);

            maybeAddParent(name);
            ZipArchiveEntry zipEntry = newZipEntryWithFixedTime(name);
            configureCompression(zipEntry, compressionMethod, content);
            outputStream.setEncoding("UTF-8");
            outputStream.putArchiveEntry(zipEntry);
            outputStream.write(content);
            outputStream.closeArchiveEntry();
        }

            getVariants() >> [rootVariant]
            getDependenciesForVariant(_) >> []
            getDependencies() >> []
        }
        Stub(Configuration) {
            getName() >> "conf"
            getIncoming() >> Mock(ResolvableDependencies) {
                getResolutionResult() >> Mock(ResolutionResult) {
                    getRootComponent() >> Providers.of(root)
                }
            }
        }
    }

        Configuration configuration = configurations.detachedConfiguration(dependency);
        configuration.setTransitive(false);
        ArtifactView lenientView = configuration.getIncoming().artifactView(view -> {
            view.setLenient(true);
        });
        return lenientView.getArtifacts().getFailures().isEmpty();
    }

                        }
                    }
                }
            }

            task lenientCheck {
                doLast {
                    def artifacts = configurations.conf.getIncoming().artifactView { lenient = true }.artifacts.artifacts
                    assert artifacts.size() == 0
                    assert candidates.empty
                }
            }
"""
        when:

                result = new LinkedHashSet<>();
                Map<ComponentIdentifier, ModuleMap> moduleMaps = new LinkedHashMap<>();
                for (ResolvedArtifactResult artifact : importPathConfig.getIncoming().getArtifacts()) {
                    Usage usage = artifact.getVariant().getAttributes().getAttribute(Usage.USAGE_ATTRIBUTE);
                    if (usage != null && Usage.C_PLUS_PLUS_API.equals(usage.getName())) {

  if (!ranked_ty) {
    return UnrankedTensorType::get(element_ty);
  }
  return RankedTensorType::get(ranked_ty.getShape(), element_ty,
                               ranked_ty.getEncoding());
}

template <typename SrcOpT, typename DstOpT>
class LowerControlFlowOp : public OpConversionPattern<SrcOpT> {
 public:
  using OpConversionPattern<SrcOpT>::OpConversionPattern;

        assertIsResolvable();

        DeprecationLogger.deprecateMethod(Configuration.class, methodName)
            .withAdvice("Use Configuration.getIncoming().artifactView(Action) with a componentFilter instead.")
            .willBeRemovedInGradle9()
            .withUpgradeGuideSection(8, "deprecate_filtered_configuration_file_and_filecollection_methods")
            .nagUser();

        public CurlResponse getResponse() {
            return response;
        }

        @Override
        public void accept(final HttpURLConnection con) {
            try {
                response.setEncoding(encoding);
                response.setHttpStatusCode(con.getResponseCode());
                response.setHeaders(con.getHeaderFields());
            } catch (final Exception e) {