)

var joinCommandTemplate = template.Must(template.New("join").Parse(`` +
	`kubeadm join {{.ControlPlaneHostPort}} --token {{.Token}} \
	{{range $h := .CAPubKeyPins}}--discovery-token-ca-cert-hash {{$h}} {{end}}{{if .ControlPlane}}\
	--control-plane {{if .CertificateKey}}--certificate-key {{.CertificateKey}}{{end}}{{end}}`,
))

// GetJoinWorkerCommand returns the kubeadm join command for a given token and

func (j *join[I]) dump() {
	log.Errorf("> BEGIN DUMP (join %v)", j.collectionName)
	for _, c := range j.collections {
		c.dump()
	}
	log.Errorf("< END DUMP (join %v)", j.collectionName)
}

func (j *join[T]) Synced() Syncer {
	return channelSyncer{
		name:   j.collectionName,
		synced: j.synced,
	}
}

// JoinCollection combines multiple Collection[T] into a single

package errors

import (
	"unsafe"
)

// Join returns an error that wraps the given errors.
// Any nil error values are discarded.
// Join returns nil if every value in errs is nil.
// The error formats as the concatenation of the strings obtained
// by calling the Error method of each element of errs, with a newline
// between each string.
//
// A non-nil error returned by Join implements the Unwrap() []error method.

	testDir := t.TempDir()
	filePaths := []string{
		filepath.Join(testDir, "0", "10.yaml"),
		filepath.Join(testDir, "0", "a", "10.yaml"),
		filepath.Join(testDir, "02.yaml"),
		filepath.Join(testDir, "10.yaml"),
		filepath.Join(testDir, "2.yaml"),
		filepath.Join(testDir, "AB.yaml"),
		filepath.Join(testDir, "a", "a.yaml"),
		filepath.Join(testDir, "a", "b.json"),
		filepath.Join(testDir, "a.yaml"),
		filepath.Join(testDir, "aa.yaml"),

	"errors"
	"reflect"
	"testing"
)

func TestJoinReturnsNil(t *testing.T) {
	if err := errors.Join(); err != nil {
		t.Errorf("errors.Join() = %v, want nil", err)
	}
	if err := errors.Join(nil); err != nil {
		t.Errorf("errors.Join(nil) = %v, want nil", err)
	}
	if err := errors.Join(nil, nil); err != nil {
		t.Errorf("errors.Join(nil, nil) = %v, want nil", err)
	}
}

func TestJoin(t *testing.T) {
	err1 := errors.New("err1")

			name: "RIGHT JOIN",
			join: clause.Join{
				Type:  clause.RightJoin,
				Table: clause.Table{Name: "user"},
				ON: clause.Where{
					Exprs: []clause.Expression{clause.Eq{clause.Column{Table: "user_info", Name: "user_id"}, clause.PrimaryColumn}},
				},
			},
			sql: "RIGHT JOIN `user` ON `user_info`.`user_id` = `users`.`id`",
		},
		{
			name: "INNER JOIN",
			join: clause.Join{
				Type:  clause.InnerJoin,

	exp = filepath.Join(root, "plugins/foobar")
	assert.Equal(t, exp, got)

	got = kubelet.getPodDir("abc123")
	exp = filepath.Join(root, "pods/abc123")
	assert.Equal(t, exp, got)

	got = kubelet.getPodVolumesDir("abc123")
	exp = filepath.Join(root, "pods/abc123/volumes")
	assert.Equal(t, exp, got)

	got = kubelet.getPodVolumeDir("abc123", "plugin", "foobar")
	exp = filepath.Join(root, "pods/abc123/volumes/plugin/foobar")

This file is not valid JSON.
-- $WORK/badproxy/example.com/join/@v/list --
v1.1.0
-- $WORK/badproxy/example.com/join/@v/v1.1.0.info --
{"Version": "v1.1.0"}
-- $WORK/emptysub/example.com/join/subpkg/@v/list --
-- $WORK/emptysub/example.com/join/@v/list --
v1.1.0
-- $WORK/emptysub/example.com/join/@v/v1.1.0.info --
{"Version": "v1.1.0"}

	RightJoin JoinType = "RIGHT"
)

// Join clause for from
type Join struct {
	Type       JoinType
	Table      Table
	ON         Where
	Using      []string
	Expression Expression
}

func (join Join) Build(builder Builder) {
	if join.Expression != nil {
		join.Expression.Build(builder)
	} else {
		if join.Type != "" {
			builder.WriteString(string(join.Type))
			builder.WriteByte(' ')
		}

	parent := t.TempDir()
	dotGit := filepath.Join(parent, ".git")
	if err := os.Mkdir(dotGit, 000); err != nil {
		t.Fatal(err)
	}

	overlayStart := time.Now()

	goroot := filepath.Join(parent, "goroot")

	gorootSrc := filepath.Join(goroot, "src")
	if err := overlayDir(gorootSrc, filepath.Join(realGoroot, "src")); err != nil {
		t.Fatal(err)
	}

	gorootLib := filepath.Join(goroot, "lib")