}
	for i, tc := range cases {
		t.Run(tc.str, func(t *testing.T) {
			jp := JSONPath{}
			err := p.ParseString(tc.str, &jp)
			// fmt.Println(jp)
			if err != nil {
				t.Fatalf("parse failed!: %d %v %s", i, err, tc)
			}

			// Read only the first json object from the file
			recs, err := getJSONStructs(b)
			if err != nil || len(recs) != 3 {
				t.Fatalf("%v or length was not 3", err)
			}

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

        return expressionDocumentation;
    }

    /**
     * <expressions>
     * <expression>

                .toSortedMap()
            val latests = buildList {
                versionsByMinor.entries.forEachIndexed { idx, entry ->
                    val versionsOfMinor = entry.value.sortedByDescending { VersionNumber.parse(it) }
                    if (idx < versionsByMinor.size - 1) {
                        // Latest of the previous minor
                        add(versionsOfMinor.first())
                    } else {

                }
                XIncludeAwareXmlProvider provider = new XIncludeAwareXmlProvider()
                def doc = new gradlebuild.docs.dsl.docbook.model.ClassDoc(className, provider.parse(classFile), document, classMetaData, extensionMetaData)
                docBuilder.build(doc)
                return doc
            } catch (ClassDocGenerationException e) {
                throw e

package cmd

import (
	"fmt"
	"net"
	"net/url"
	"path/filepath"
	"reflect"
	"strings"
	"testing"
)

func TestNewEndpoint(t *testing.T) {
	u2, _ := url.Parse("https://example.org/path")
	u4, _ := url.Parse("http://192.168.253.200/path")
	rootSlashFoo, _ := filepath.Abs("/foo")
	testCases := []struct {
		arg              string
		expectedEndpoint Endpoint
		expectedType     EndpointType

    val immutable: Boolean = cacheControl.immutable
    val forceCache: CacheControl = CacheControl.FORCE_CACHE
    val forceNetwork: CacheControl = CacheControl.FORCE_NETWORK
    val parse: CacheControl = CacheControl.parse(headersOf())
  }

  @Test
  fun cacheControlBuilder() {
    var builder: CacheControl.Builder = CacheControl.Builder()
    builder = builder.noCache()
    builder = builder.noStore()

    @get:OutputDirectory
    abstract val receiptFolder: DirectoryProperty

    fun buildTimestampFrom(provider: Provider<String>) {
        buildTimestamp = provider.map { buildTimestampString -> timestampFormat.parse(buildTimestampString) }
    }

    @TaskAction
    fun generate() {
        if (promotionBuild.get()) {
            logger.logBuildVersion()
        }

pkg text/template/parse, type DotNode struct, embedded NodeType
pkg text/template/parse, type NilNode struct, embedded NodeType
pkg text/template/parse, method (*BranchNode) Copy() Node
pkg text/template/parse, method (*IdentifierNode) SetTree(*Tree) *IdentifierNode
pkg html/template, type Error struct, Node parse.Node

                }
            }
        } catch (ParseException e) {
            System.err.println("Unable to parse maven.config file options: " + e.getMessage());
            cliManager.displayHelp(System.out);
            throw e;
        }

        try {
            CommandLine mavenCli = cliManager.parse(cliRequest.args);
            if (mavenConfig == null) {
                cliRequest.commandLine = mavenCli;

import org.apache.maven.api.annotations.Consumer;
import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nonnull;
import org.apache.maven.api.annotations.Nullable;

/**
 * Parses and evaluates version ranges encountered in dependency declarations.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
public interface VersionRangeResolver extends Service {

    /**