import org.gradle.internal.declarativedsl.parsing.ParseTestUtil
import org.gradle.internal.declarativedsl.parsing.assert
import org.junit.jupiter.api.Test


class BasicParsingTest {

    @Test
    fun `parses literals`() {
        val results = parse(
            """
            a = 1
            b = "test"
            c = ${'"'}""test${'"'}""
            e = true
            d = false
            """.trimIndent()
        )

     * @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}

 */

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",

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

		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)

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.

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/," +

        parse('one-version')

        then:
        hasVersion('guava', '17')
    }

    def "parses a file with a single plugin and nothing else"() {
        when:
        parse('one-plugin')

        then:
        hasPlugin('greeter', 'org.example.greeter', '1.13')
    }

    def "parses dependencies with various notations"() {
        when:
        parse 'dependency-notations'

The new [ParseOID] function parses a dot-encoded ASN.1 Object Identifier string.
The [OID] type now implements the [encoding.BinaryMarshaler],

		return true
	default:
		return false
	}
}

// taggedName parses:
//
//	<tagged-name> ::= <name> B <source-name>
func (st *state) taggedName(a AST) AST {
	for len(st.str) > 0 && st.str[0] == 'B' {
		st.advance(1)
		tag := st.sourceName()
		a = &TaggedName{Name: a, Tag: tag}
	}
	return a
}

// name parses:
//
//	<name> ::= <nested-name>
//	       ::= <unscoped-name>