// ParseProfiles parses profile data in the specified file and returns a
// Profile for each source file described therein.
func ParseProfiles(fileName string) ([]*Profile, error) {
	pf, err := os.Open(fileName)
	if err != nil {
		return nil, err
	}
	defer pf.Close()
	return ParseProfilesFromReader(pf)
}

// ParseProfilesFromReader parses profile data from the Reader and

}

var errMalformedTree = errors.New("malformed tree note")
var treePrefix = []byte("go.sum database tree\n")

// ParseTree parses a formatted tree root description.
func ParseTree(text []byte) (tree Tree, err error) {
	// The message looks like:
	//
	//	go.sum database tree
	//	2
	//	nND/nri/U0xuHUrYSy0HtMeal2vzD9V4k/BO79C+QeI=
	//
	// For forwards compatibility, extra text lines after the encoding are ignored.

package org.gradle.api.internal.artifacts.dsl;

import org.gradle.api.capabilities.Capability;
import org.gradle.internal.typeconversion.NotationParser;

/**
 * A concrete type for a generic {@link NotationParser} that parses {@link Capability}s.
 * <p>
 * This concrete type is necessary so that it can be injected into version catalog generated sources.
 */
public interface CapabilityNotationParser extends NotationParser<Object, Capability> {

 The jar file is executable and provides a little tool to display how Maven parses and compares versions:

+----+
$ java -jar maven-artifact-*.jar 3.2.4-alpha-1 3.2.4-SNAPSHOT 3.2.4.0
Display parameters as parsed by Maven (in canonical form) and comparison result:
1. 3.2.4-alpha-1 == 3.2.4.alpha.1
   3.2.4-alpha-1 < 3.2.4-SNAPSHOT
2. 3.2.4-SNAPSHOT == 3.2.4.snapshot

  def converter = new ProjectPropertiesCommandLineConverter();

  def convert(String... args) {
    converter.convert(Arrays.asList(args), new HashMap<String, String>()).sort()
  }

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

package net

// parsePort parses service as a decimal integer and returns the
// corresponding value as port. It is the caller's responsibility to
// parse service as a non-decimal integer when needsLookup is true.
//
// Some system resolvers will return a valid port number when given a number
// over 65536 (see https://golang.org/issues/11715). Alas, the parser

package org.gradle.process.internal.health.memory

import spock.lang.Specification

class CGroupMemoryInfoTest extends Specification {
    private static final long MB_IN_BYTES = 1024 * 1024 * 1024

    def "parses memory from cgroup values"() {
        def snapshot = new CGroupMemoryInfo().getOsSnapshotFromCgroup(mbsToBytesAsString(800), mbsToBytesAsString(1024))

        expect:
        snapshot.physicalMemory.total == mbsToBytes(1024)

public class TypedNotationConverterTest extends Specification {

    def parser = NotationParserBuilder.toType(Integer).converter(new DummyConverter()).toComposite()

    def "parses object of source type"(){
        expect:
        parser.parseNotation("100") == 100
    }

    def "throws meaningful exception on parse attempt"(){
        when:
        parser.parseNotation(new Object())

        then:

*/

package util

import (
	"bytes"
	"text/template"

	"github.com/pkg/errors"
)

// ParseTemplate validates and parses passed as argument template
func ParseTemplate(strtmpl string, obj interface{}) ([]byte, error) {
	var buf bytes.Buffer
	tmpl, err := template.New("template").Parse(strtmpl)
	if err != nil {
		return nil, errors.Wrap(err, "error when parsing template")
	}
	err = tmpl.Execute(&buf, obj)

)

// MakeChainLine return an iptables-save/restore formatted chain line given a Chain
func MakeChainLine(chain Chain) string {
	return fmt.Sprintf(":%s - [0:0]", chain)
}

// GetChainsFromTable parses iptables-save data to find the chains that are defined. It
// assumes that save contains a single table's data, and returns a set with keys for every
// chain defined in that table.