}
    }

    def "parses minimal metadata resource"() {
        def metadata = Mock(MutableModuleComponentResolveMetadata)

        when:
        parser.parse(resource('{ "formatVersion": "1.1" }'), metadata)

        then:
        1 * metadata.getMutableVariants()
        0 * metadata._
    }

    def "parses minimal metadata with identity and producer information"() {

    def "parses module identifier notation"() {
        expect:
        parser.parseNotation("org.gradle:gradle-core") == new UnversionedModuleComponentSelector(moduleIdentifierFactory.module("org.gradle", "gradle-core"))
        parser.parseNotation(" foo:bar ") == new UnversionedModuleComponentSelector(moduleIdentifierFactory.module("foo", "bar"))
    }

    def "parses module component identifier notation"() {

"This is not json"

 * limitations under the License.
 */
package gradlebuild.docs

import org.w3c.dom.*
import org.xml.sax.InputSource
import spock.lang.Specification

import javax.xml.parsers.DocumentBuilder
import javax.xml.parsers.DocumentBuilderFactory

abstract class XmlSpecification extends Specification {
    final Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()

	}
	return x, nil
}

// or parses a sequence of || expressions.
// On entry, the next input token has not yet been lexed.
// On exit, the next input token has been lexed and is in p.tok.
func (p *exprParser) or() Expr {
	x := p.and()
	for p.tok == "||" {
		x = or(x, p.and())
	}
	return x
}

// and parses a sequence of && expressions.

    }

    // ----------------------------------------------------------------------
    // Implementation methods
    // ----------------------------------------------------------------------

    /**
     * Parses a sequence of XML elements and converts them to the given target type.
     *
     * @param parser The XML parser
     * @param toType The target type
     * @return Converted instance of the target type
     */

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

        then:
        InvalidUserDataException ex = thrown()
        verify(ex.message, undefinedAliasRef {
            inCatalog('libs')
            bundle('guava')
            aliasRef('hello')
        })
    }

    def "parses a file with a single version and nothing else"() {

		}

		// overrides the control-plane url using the controlPlaneAddress (and eventually the bindport)
		return formatURL(host, port).String(), nil
	}

	return localAPIEndpoint, nil
}

// GetLocalAPIEndpoint parses an APIEndpoint and returns it as a string,
// or returns and error in case it cannot be parsed.
func GetLocalAPIEndpoint(localEndpoint *kubeadmapi.APIEndpoint) (string, error) {
	// get the URL of the local endpoint

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * A {@link org.gradle.api.Plugin} for generating parsers from Antlr grammars.
 */

}

func TestParseFS(t *testing.T) {
	fs := os.DirFS("testdata")

	{
		_, err := ParseFS(fs, "DOES NOT EXIST")
		if err == nil {
			t.Error("expected error for non-existent file; got none")
		}
	}

	{
		template := New("root")
		_, err := template.ParseFS(fs, "file1.tmpl", "file2.tmpl")
		if err != nil {
			t.Fatalf("error parsing files: %v", err)
		}