var s Sym
	s.SetABI(1)
	s.SetType(uint8(objabi.STEXT))
	s.SetFlag(0x12)
	s.SetSiz(12345)
	s.SetAlign(8)
	s.Write(w)

	var r Reloc
	r.SetOff(12)
	r.SetSiz(4)
	r.SetType(uint16(objabi.R_ADDR))
	r.SetAdd(54321)
	r.SetSym(SymRef{11, 22})
	r.Write(w)

	var a Aux
	a.SetType(AuxFuncInfo)
	a.SetSym(SymRef{33, 44})
	a.Write(w)

	w.wr.Flush()

	// Read them back and check.
	b := buf.Bytes()

        return super.visit(visitor);
    }

    @Override
    public PatternSet getPatterns() {
        return patternSet;
    }

    @Override
    public DefaultConfigurableFileTree setDir(Object dir) {
        from(dir);
        return this;
    }

    @Override
    public File getDir() {
        if (dir == null) {

        return excludes;
    }

    public void setExcludes(List<String> excludes) {
        this.excludes = excludes;
    }

    public File getDir() {
        return dir;
    }

    public void setDir(File dir) {
        this.dir = dir;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override

	return nil
}

func (f *FakeCmd) CombinedOutput() ([]byte, error) {
	return f.out, f.err
}

func (f *FakeCmd) Output() ([]byte, error) {
	return f.stdout, f.err
}

func (f *FakeCmd) SetDir(dir string) {}

func (f *FakeCmd) SetStdin(in io.Reader) {}

func (f *FakeCmd) SetStdout(out io.Writer) {
	f.writer = out
}

func (f *FakeCmd) SetStderr(out io.Writer) {
	f.writer = out
}

        when:
        def fileTree = fileOperations.fileTree(dir: 'base')

        then:
        fileTree.is(tree)
        1 * fileCollectionFactory.fileTree() >> tree
        1 * tree.setDir('base')
    }

    def createsZipFileTree() {
        expectPathResolved('path')
        expectTempFileCreated()
        when:
        def zipTree = fileOperations.zipTree('path')

        then:

			case xcoff.R_RBR:
				rSize = 4
				rType = objabi.R_CALLPOWER
				rAdd = 0
			}
			r, _ := sb.AddRel(rType)
			r.SetOff(rOff)
			r.SetSiz(rSize)
			r.SetSym(rSym)
			r.SetAdd(rAdd)
		}
	}
	return textp, nil
}

// Convert symbol xcoff type to sym.SymKind
// Returns nil if this shouldn't be added into loader (like .file or .dw symbols )

}

func (b *gitRepoVolumeMounter) execCommand(command string, args []string, dir string) ([]byte, error) {
	cmd := b.exec.Command(command, args...)
	cmd.SetDir(dir)
	return cmd.CombinedOutput()
}

func validateVolume(src *v1.GitRepoVolumeSource) error {
	if err := validateNonFlagArgument(src.Repository, "repository"); err != nil {
		return err
	}

}

func (mfc *monitorFakeCmd) Run() error {
	panic("should not be reached")
}

func (mfc *monitorFakeCmd) Output() ([]byte, error) {
	panic("should not be reached")
}

func (mfc *monitorFakeCmd) SetDir(dir string) {
	panic("should not be reached")
}

func (mfc *monitorFakeCmd) SetStdout(out io.Writer) {
	panic("should not be reached")
}

func (mfc *monitorFakeCmd) SetStderr(out io.Writer) {

func (eic *execInContainer) CombinedOutput() ([]byte, error) {
	return eic.run()
}

func (eic *execInContainer) Output() ([]byte, error) {
	return nil, fmt.Errorf("unimplemented")
}

func (eic *execInContainer) SetDir(dir string) {
	// unimplemented
}

func (eic *execInContainer) SetStdin(in io.Reader) {
	// unimplemented
}

func (eic *execInContainer) SetStdout(out io.Writer) {
	eic.writer = out
}