/**
 * A factory for creating {@link Action}s from CLI commands.
 */
public interface CommandLineActionCreator {
    /**
     * Configures the given action creator with a command-line parser.
     */
    void configureCommandLineParser(CommandLineParser parser);

    /**
     * Creates an executable action from the given command-line args.
     *

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.List;

public class SnappyDainPacker implements Packer {
    private final Packer delegate;

    public SnappyDainPacker(Packer delegate) {
        this.delegate = delegate;
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {

-- pkg.go --
package pkg_test

import "runtime"

func PrintFile() {
	_, file, _, _ := runtime.Caller(0)
	println(file)
}

-- pkg_x_test.go --
package pkg_test_test

import (
	"runtime"
	"testing"

	"example.com/pkg_test"
)

func PrintFileForTest() {
	_, file, _, _ := runtime.Caller(0)
	println(file)
}

func TestMain(m *testing.M) {
	pkg_test.PrintFile()
	PrintFileForTest()

	"k8s.io/kubernetes/pkg/controller"
)

func TestSyncClusterRole(t *testing.T) {
	hammerRules := func() []rbacv1.PolicyRule {
		return []rbacv1.PolicyRule{
			{Verbs: []string{"hammer"}, Resources: []string{"nails"}},
			{Verbs: []string{"hammer"}, Resources: []string{"wedges"}},
		}
	}
	chiselRules := func() []rbacv1.PolicyRule {
		return []rbacv1.PolicyRule{
			{Verbs: []string{"chisel"}, Resources: []string{"mortises"}},
		}

    def packer = Mock(BuildCacheEntryPacker)
    def originFactory = Mock(OriginMetadataFactory)
    def stringInterner = new StringInterner()
    def buildOperationContext = Mock(BuildOperationContext)
    def buildOperationRunner = Mock(BuildOperationRunner)
    PackOperationExecutor packOperationExecutor = new PackOperationExecutor(buildOperationRunner, packer, originFactory, stringInterner)

    }

    InitialProperties properties(String... args) {
        def parser = new CommandLineParser()
        def initialPropertiesConverter = new InitialPropertiesConverter()
        initialPropertiesConverter.configure(parser)
        def parsedCommandLine = parser.parse(args)
        return initialPropertiesConverter.convert(parsedCommandLine)
    }

// in the plugin for Training. The API takes in the context with indices for
// the input and value tensors. It also accepts the copy callback provided by
// pluggable vendor to do the copying of the tensors. The caller takes ownership
// of the `source` and `dest` tensors and is responsible for freeing them with
// TF_DeleteTensor. This function will return an error when the following
// conditions are met:

import static org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.PomDomParser.AddDTDFilterInputStream;
import static org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.PomDomParser.getAllChilds;
import static org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.PomDomParser.getFirstChildElement;
import static org.gradle.api.internal.artifacts.ivyservice.ivyresolve.parser.PomDomParser.getFirstChildText;

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package syntax

import (
	"fmt"
	"io"
	"os"
)

// Mode describes the parser mode.
type Mode uint

// Modes supported by the parser.
const (
	CheckBranches Mode = 1 << iota // check correct use of labels, break, continue, and goto statements
)

// Error describes a syntax error. Error implements the error interface.

        given:
        bytecodeInterceptorFilter = BytecodeInterceptorFilter.ALL
        resetInterceptors()

        when:
        def intercepted = interceptedWhen(shouldDelegate, invocation)

        then:
        intercepted == expected

        where: