@ElementTypesAreNonnullByDefault
public final class Reflection {

  /**
   * Returns the package name of {@code clazz} according to the Java Language Specification (section
   * 6.7). Unlike {@link Class#getPackage}, this method only parses the class name, without
   * attempting to define the {@link Package} and hence load files.
   */
  public static String getPackageName(Class<?> clazz) {
    return getPackageName(clazz.getName());
  }

  /**

    def converter = new SystemPropertiesCommandLineConverter();

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

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

//
// If src != nil, ParseFile parses the source from src and the filename is
// only used when recording position information. The type of the argument
// for the src parameter must be string, []byte, or [io.Reader].
// If src == nil, ParseFile parses the file specified by filename.
//
// The mode parameter controls the amount of source text parsed and
// other optional parser functionality. If the [SkipObjectResolution]

class TimeUnitsParserTest extends Specification {

    def parser = new TimeUnitsParser()

    def "parses time units"() {
        expect:
        def unit = parser.parseNotation(input, value)
        unit.value == normalizedValue
        unit.timeUnit == parsed

        where:
        value           |input          |parsed         | normalizedValue
        10              |'nanoseconds'  |NANOSECONDS    |10

package format_test

import (
	"bytes"
	"fmt"
	"go/format"
	"go/parser"
	"go/token"
	"log"
)

func ExampleNode() {
	const expr = "(6+2*3)/4"

	// parser.ParseExpr parses the argument and returns the
	// corresponding ast.Node.
	node, err := parser.ParseExpr(expr)
	if err != nil {
		log.Fatal(err)
	}

	// Create a FileSet for node. Since the node does not come

import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableMap;
import java.util.Deque;

/** Parser for a map of reversed domain names stored as a serialized radix tree. */
@GwtCompatible
final class TrieParser {

  private static final Joiner DIRECT_JOINER = Joiner.on("");

  /**
   * Parses a serialized trie representation of a map of reversed public suffixes into an immutable

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// The parser no longer parses type parameters for methods.
// In the past, type checking the code below led to a crash (#50427).

type T interface{ m[ /* ERROR "must have no type parameters" */ P any]() }

func _(t T) {

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

// This is a sample chained plugin that supports multiple CNI versions. It
// parses prevResult according to the cniVersion
package plugin

import "errors"

// ErrNotImplemented is returned when a requested feature is not implemented.
var ErrNotImplemented = errors.New("not implemented")

			Name:        &epp.Name,
			Port:        &epp.Port,
			Protocol:    &epp.Protocol,
			AppProtocol: epp.AppProtocol,
		})
	}
	return epsPorts
}

// getServiceFromDeleteAction parses a Service resource from a delete
// action.
func getServiceFromDeleteAction(obj interface{}) *corev1.Service {
	if service, ok := obj.(*corev1.Service); ok {
		return service
	}

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

// This is a sample chained plugin that supports multiple CNI versions. It
// parses prevResult according to the cniVersion
package plugin

type iptables struct{}

func newIPTables() InterceptRuleMgr {
	return &iptables{}