}

    def "parses map notation for library in other project"() {
        when:
        def input = [project: 'other', library: 'libName']
        def dependency = parser.parseNotation(input)


        then:
        dependency.projectPath == "other"
        dependency.libraryName == "libName"
        dependency.linkage == null
    }

    def "parses map notation for library with defined linkage"() {

/**
 * Service interface to parse {@link Version} and {@link VersionRange}.
 *
 * @since 4.0.0
 */
@Experimental
public interface VersionParser extends Service {

    /**
     * Parses the specified version string, for example "1.0".
     *
     * @param version the version string to parse, must not be {@code null}
     * @return the parsed version, never {@code null}

import spock.lang.Specification

class MetadataExtracterTest extends Specification {

    def "parses package information when defined in a separate line"() {
        given:
        def grammar = """
        header {
            package org.acme;
        }

        class TestGrammar extends Parser;

        options {
            buildAST = true;
        }

        expr:   mexpr (PLUS^ mexpr)* SEMI!

     * @return the parsed version, never {@code null}
     * @throws VersionParserException if the string violates the syntax rules of this scheme
     */
    @Nonnull
    Version parseVersion(@Nonnull String version);

    /**
     * Parses the specified version range specification, for example "[1.0,2.0)".
     *
     * @param range the range specification to parse, must not be {@code null}

}

// Part is a single-part yaml source, along with its descriptor.
type Part struct {
	Contents   string
	Descriptor Descriptor
}

// Parse parses the given multi-part yaml text, and returns as Parts.
func Parse(yamlText string) ([]Part, error) {
	splitContent := SplitString(yamlText)
	parts := make([]Part, 0, len(splitContent))
	for _, part := range splitContent {
		if len(part) > 0 {

 */

package gradlebuild.binarycompatibility

import spock.lang.Specification

class AcceptedApiChangesTest extends Specification {

    def "parses accepted change"() {
        when:
        def changes = AcceptedApiChanges.parse(["""
            {
                "acceptedApiChanges": [
                    {
                        "type": "org.gradle.api.initialization.ConfigurableIncludedBuild",

type EtcdVersion struct {
	semver.Version
}

// ParseEtcdVersion parses a SemVer string to an EtcdVersion.
func ParseEtcdVersion(s string) (*EtcdVersion, error) {
	v, err := semver.Make(s)
	if err != nil {
		return nil, err
	}
	return &EtcdVersion{v}, nil
}

// MustParseEtcdVersion parses a SemVer string to an EtcdVersion and panics if the parse fails.
func MustParseEtcdVersion(s string) *EtcdVersion {

	// Add new AMZ date formats here.
}

// ErrMalformedDate always returned for dates that cannot be parsed.
var ErrMalformedDate = errors.New("malformed date")

// Parse parses date string via supported amz date formats.
func Parse(amzDateStr string) (time.Time, error) {
	for _, dateFormat := range amzDateFormats {
		amzDate, err := time.Parse(dateFormat, amzDateStr)
		if err == nil {
			return amzDate, nil
		}
	}

The new [ParseCookie] function parses a Cookie header value and
returns all the cookies which were set in it. Since the same cookie
name can appear multiple times the returned Values can contain
more than one value for a given key.

The new [ParseSetCookie] function parses a Set-Cookie header value and

        parser.parseNotation(" foo:bar ") == new UnversionedModuleComponentSelector(moduleIdentifierFactory.module("foo", "bar"))
    }

    def "parses module component identifier notation"() {
        expect:
        parser.parseNotation("org.gradle:gradle-core:1.+") == DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId("org.gradle", "gradle-core"), new DefaultMutableVersionConstraint("1.+"))