apiClass.newClass >> Optional.of(newIncubatingBase)
        newSuper.addInterface(incubatingInterface)

        expect:
        noViolation(rule)
    }

    def "adding an #type interface to super class would not be reported"() {
        given:
        newSuper.addInterface(interfaces[type])

        expect:
        noViolation(rule)

        where:
        type << ['internal', 'incubating']
    }

            current = classesContainingMethod.get(i)
            if (!isInternal(current)) {
                // there's another public super class which contains target method
                // it would be reported somewhere else
                return false
            }
        }

        // I'm the top public class which contains target method
        return true
    }

            try {
                return parse(rawCommentText, classMetaData, new NoOpCommentSource(), listener);
            } catch (Exception e) {
                throw new GradleException(String.format("Could not convert javadoc comment to docbook.%nClass: %s%nComment: %s", classMetaData, rawCommentText), e);
            }
        } finally {
            listener.finish();
        }
    }

For any non-trivial change, we need to be able to answer these questions:

* Why is this change done? What's the use case?
* For user facing features, what will the API look like?
* What test cases should it have? What could go wrong?
* How will it roughly be implemented? We'll happily provide code pointers to save you time.

We may ask you to answer these questions directly in the GitHub issue or (for large changes) in a shared Google Doc.

        "it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet",
    )
)
plugins.withId("java-base") {
    dependencies {
        attributesSchema {
            attribute(minified)
        }
        // It would be nice if we could be more selective about which variants to apply this to.
        // TODO https://github.com/gradle/gradle/issues/11831#issuecomment-580686994
        artifactTypes.getByName("jar") {

    const {length} = slashes
    return slashes.slice(0, length - length % 2)
}

// > If the pattern ends with a slash,
// > it is removed for the purpose of the following description,
// > but it would only find a match with a directory.
// > In other words, foo/ will match a directory foo and paths underneath it,
// > but will not match a regular file or a symbolic link foo

        Node node = doResolve(link, classMetaData, listener);
        if (node != null) {
            return node;
        }

        listener.warning(String.format("Could not convert Javadoc link '%s'", link));
        Element element = document.createElement("UNHANDLED-LINK");
        element.appendChild(document.createTextNode(link));
        return element;
    }

    public abstract DirectoryProperty getDestinationDirectory();

    @Inject
    protected abstract FileSystemOperations getFs();

    @TaskAction
    public void generate() {
        // TODO: This could probably use InputChanges API
        File destinationDirectory = getDestinationDirectory().get().getAsFile();
        getFs().delete(spec -> spec.delete(destinationDirectory));
        destinationDirectory.mkdirs();

                    visitTree(classDetails, classesDir, jarOutputStream, visited)
                }
            }
        } catch (exception: Exception) {
            throw ClassAnalysisException("Could not write shaded Jar $jarFile", exception)
        }
    }

    private
    fun visitTree(
        classDetails: ClassDetails,
        classesDir: File,
        jarOutputStream: JarOutputStream,

                            writeBytes(classWriter.toByteArray())
                        }
                    } catch (exception: Exception) {
                        throw ClassAnalysisException("Could not transform class from ${file.toFile()}", exception)
                    }
                }
            }
        )
    }
}


fun JarOutputStream.addJarEntry(entryName: String, sourceFile: File) {