PluginContainer childContainer, PluginContainer parentContainer, boolean handleAsInheritance) {
        throw new UnsupportedOperationException();
    }

    public static List<Plugin> orderAfterMerge(
            List<Plugin> merged, List<Plugin> highPrioritySource, List<Plugin> lowPrioritySource) {
        throw new UnsupportedOperationException();
    }

        try {
            return new Metadata(delegate.read(reader, strict));
        } catch (XMLStreamException e) {
            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

    /**
     * Method read.
     *
     * @param reader a reader object.
     * @return Metadata

            if (cells.size() != header.size()) {
                throw new RuntimeException(String.format("Expected %s <td> elements in <tr>, found: %s", header.size(), tr));
            }
            String propName = cells.get(0).getTextContent().trim();
            PropertyMetaData property = classDoc.getClassMetaData().findProperty(propName);
            if (property == null) {

            throw result.getVersionRangeViolation(0);
        }

        // Transfer Error

        if (result.hasErrorArtifactExceptions()) {
            throw result.getErrorArtifactExceptions().get(0);
        }

        if (result.hasMissingArtifacts()) {
            throw new MultipleArtifactsNotFoundException(
                    request.getArtifact(),
                    toList(result.getArtifacts()),

            return parseArgs("atFile", args);
        } catch (ParseException e) {
            throw new IllegalArgumentException(
                    "Failed to parse arguments from file (" + atFile + "): " + e.getMessage(), e.getCause());
        } catch (IOException e) {
            throw new IllegalStateException("Error reading config file: " + atFile, e);
        }
    }

            return container.lookup(type);
        } catch (ComponentLookupException e) {
            throw new LookupException(e);
        }
    }

    @Override
    public <T> T lookup(Class<T> type, String name) {
        try {
            return container.lookup(type, name);
        } catch (ComponentLookupException e) {
            throw new LookupException(e);
        }
    }

    @Override

        for (Entry<Object, Object> provide : provides.entrySet()) {
            String key = (String) provide.getKey();
            String value = (String) provide.getValue();

            if (value == null) {
                throw new MisconfiguredToolchainException(
                        "Provides token '" + key + "' doesn't have any value configured.");
            }

            RequirementMatcher matcher;
            if ("version".equals(key)) {

func TestErroneous(t *testing.T) {

	type errtest struct {
		pseudo   string
		operands string
		expected string
	}

	nonRuntimeTests := []errtest{
		{"TEXT", "", "expect two or three operands for TEXT"},
		{"TEXT", "%", "expect two or three operands for TEXT"},
		{"TEXT", "1, 1", "TEXT symbol \"<erroneous symbol>\" must be a symbol(SB)"},
		{"TEXT", "$\"foo\", 0, $1", "TEXT symbol \"<erroneous symbol>\" must be a symbol(SB)"},

            }
        } catch (IOException e) {
            throw new GradleException(String.format("Could not write meta-data to %s.", repoFile), e);
        }
    }

    @Override
    public T get(String fullyQualifiedClassName) {
        T t = find(fullyQualifiedClassName);
        if (t == null) {

                    }
                } catch (IOException e) {
                    throw new ExpressionDocumentationException(
                            "Failed to read documentation for expression root: " + root, e);
                } catch (XmlPullParserException e) {
                    throw new ExpressionDocumentationException(
                            "Failed to parse documentation for expression root: " + root, e);