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.+"))

            1 * parser.option(converter.propertyOption, converter.propertyOptionDetailed) >> option
    }

    def "parses properties args"() {
        expect:
        convert("-Aa=b", "-Ac=d") == [a: "b", c: "d"]
    }

    def "parses properties args with no property value"() {
        expect:
        convert("-Aa", "-Ab=") == [a: "", b: ""]
    }

    def "parses properties arg containing equals"() {

}

// ParseFS is like [Template.ParseFiles] or [Template.ParseGlob] but reads from the file system fsys
// instead of the host operating system's file system.
// It accepts a list of glob patterns (see [path.Match]).
// (Note that most file names serve as glob patterns matching only themselves.)
func ParseFS(fsys fs.FS, patterns ...string) (*Template, error) {
	return parseFS(nil, fsys, patterns)
}

		return cmp.Compare(g.byLabel[a], g.byLabel[b])
	})
	return edges
}

// Parse parses the DAG language and returns the transitive closure of
// the described graph. In the returned graph, there is an edge from "b"
// to "a" if b < a (or a > b) in the partial order.
func Parse(dag string) (*Graph, error) {
	g := newGraph()
	disallowed := []rule{}

	rules, err := parseRules(dag)

};

// Parses the command line flag strings to the specification of nodes in
// the Graph.
Status ParseOutputArrayInfo(absl::string_view array_names,
                            std::vector<string>* outputs);

Status ParseOutputArrayInfo(const std::vector<string>& output_names,
                            std::vector<string>* outputs);

The `cmd` directory contains helpful tools for debugging traces.

* `gotraceraw` parses traces without validation.
  It can produce a text version of the trace wire format, or convert
  the text format back into bytes.
* `gotracevalidate` parses traces and validates them.
  It performs more rigorous checks than the parser does on its own,
  which helps for debugging the parser as well.

			nskips++
		} else {
			msgs = append(msgs, m)
		}
		b = b[any.Msglen:]
	}
	// We failed to parse any of the messages - version mismatch?
	if nmsgs != len(msgs)+nskips {
		return nil, EINVAL
	}
	return msgs, nil
}

// ParseRoutingSockaddr parses msg's payload as raw sockaddrs and
// returns the slice containing the [Sockaddr] interfaces.
//

	}
}

// implPath parses:
//
//	<impl-path> = [<disambiguator>] <path>
func (rst *rustState) implPath() {
	// This path is not part of the demangled string.
	hold := rst.skip
	rst.skip = true
	defer func() {
		rst.skip = hold
	}()

	rst.disambiguator()
	rst.path(false)
}

// identifier parses:
//

}

// A SyntaxError reports a syntax error in a parsed build expression.
type SyntaxError struct {
	Offset int    // byte offset in input where error was detected
	Err    string // description of error
}

func (e *SyntaxError) Error() string {
	return e.Err
}

var errNotConstraint = errors.New("not a build constraint")

import org.gradle.launcher.daemon.context.DaemonContext
import org.gradle.util.GradleVersion
import spock.lang.Specification

class DaemonContextParserTest extends Specification {
    def "parses entries for older versions of Gradle"() {
        def contextString = "DefaultDaemonContext[" +
            "uid=4224e700-9e7c-4964-ad43-d6950d561cc0," +
            "javaHome=/usr/bin/java/," +