#
# Usage: rename_and_verify_wheels.sh
# This script is aware of TFCI_ variables, so it doesn't need any arguments.
# Puts new wheel through auditwheel to rename and verify it, deletes the old
# one, checks the filesize, and then ensures the new wheel is installable.
set -exo pipefail

cd "$TFCI_OUTPUT_DIR"

# Move extra wheel files somewhere out of the way. This script

            if (className == null) {
                return null;
            }
        }
        if (matcher.group(2) == null) {
            return linkRenderer.link(new TypeMetaData(className), listener);
        }

        ClassMetaData targetClass;
        if (className != null) {
            targetClass = repository.find(className);
            if (targetClass == null) {

     * Updates the model version element in a POM document.
     *
     * @param pomDocument the POM document (domtrip Document)
     * @param newVersion the new model version
     */
    public static void updateModelVersion(Document pomDocument, String newVersion) {
        Editor editor = new Editor(pomDocument);
        Element root = editor.root();
        if (root == null) {
            return;
        }

    private static final Pattern SETTER_METHOD_NAME = Pattern.compile("set(.+)");
    private final List<ClassMetaData> allClasses = new ArrayList<ClassMetaData>();
    private final Deque<ClassMetaData> classStack = new LinkedList<ClassMetaData>();
    private String packageName;

    @Override
    public void visit(CompilationUnit compilationUnit, ClassMetaDataRepository<ClassMetaData> repository) {

     * @return The user-friendly source hint, never {@code null}.
     */
    static String toSourceHint(Model model) {
        if (model == null) {
            return "";
        }

        StringBuilder buffer = new StringBuilder(128);

        buffer.append(toId(model));

        File pomFile = model.getPomFile();
        if (pomFile != null) {
            buffer.append(" (").append(pomFile).append(')');
        }

     */
    @Nullable
    Path getPath();

    /**
     * Creates a new input stream to read the source contents.
     * Each call creates a fresh stream starting from the beginning.
     * The caller is responsible for closing the returned stream.
     *
     * @return a new input stream positioned at the start of the content
     * @throws IOException if the stream cannot be created or opened
     */

 */
public abstract class LayeredOptions<O extends Options> implements Options {
    protected final List<O> options;

    protected LayeredOptions(List<O> options) {
        this.options = new ArrayList<>(options);
    }

    @Override
    public Optional<Map<String, String>> userProperties() {
        return collectMapIfPresentOrEmpty(Options::userProperties);
    }

    @Override

    init {
        id("Promotion_SnapshotFromQuickFeedback")
        name = "Nightly Snapshot (from QuickFeedback)"
        description = "Promotes the latest successful changes on '${branch.branchName}' from Quick Feedback as a new nightly snapshot"
    }

import static org.junit.jupiter.api.Assertions.assertTrue;

class MavenPluginJavaPrerequisiteCheckerTest {

    @Test
    void testMatchesVersion() {
        MavenPluginJavaPrerequisiteChecker checker = new MavenPluginJavaPrerequisiteChecker(new GenericVersionScheme());
        assertTrue(checker.matchesVersion("1.0", "1.8"));
        assertTrue(checker.matchesVersion("1.8", "9.0.1+11"));
        assertFalse(checker.matchesVersion("[1.0,2],[3,4]", "2.1"));

        }
        return Optional.of(new DefaultPackaging(id, type, getPlugins(lifecycleMapping)));
    }

    private Map<String, PluginContainer> getPlugins(LifecycleMapping lifecycleMapping) {
        Map<String, PluginContainer> lfs = new HashMap<>();
        lifecycleMapping.getLifecycles().forEach((id, lifecycle) -> {
            Map<String, Plugin> plugins = new HashMap<>();
            lifecycle