}

        file("gradle/verification-keyring.dryrun.keys") << "trash"
        file("gradle/verification-keyring.dryrun.gpg") << "trash"
        file("gradle/verification-metadata.dryrun.xml") << "trash"

        given:
        javaLibrary()
        uncheckedModule("org", "foo", "1.0") {
            withSignature {

	}
	defer os.RemoveAll(tmpDir)
	fullPath := filepath.Join(tmpDir, testConfigTokenFile)

	// test dryRun = false on a non-exisiting file
	if _, err = cmdutil.GetClientSet(fullPath, false); err == nil {
		t.Errorf("GetClientSet(); dry-run: false; did no fail for test file %q: %v", fullPath, err)
	}

	// test dryRun = true on a non-exisiting file
	if _, err = cmdutil.GetClientSet(fullPath, true); err == nil {

	return size - c.Used()
}

func (c *MetaAllocator) EnableMetrics() {}

// DryRun returns a random allocator
func (c *MetaAllocator) DryRun() Interface {
	c.muTree.Lock()
	defer c.muTree.Unlock()
	isIPv6 := c.ipFamily == api.IPFamily(v1.IPv6Protocol)
	for _, allocator := range c.tree.TopLevelPrefixes(isIPv6) {
		return allocator.DryRun()
	}
	return &Allocator{}
}

			expectUsed(t, r, baseUsed)

			err = r.DryRun().Allocate(netutils.AddIPOffset(netutils.BigForIP(cidr.IP), 1))
			if err != nil {
				t.Fatalf("unexpected failure: %v", err)
			}
			expectUsed(t, r, baseUsed)

			_, err = r.DryRun().AllocateNext()
			if err != nil {
				t.Fatalf("unexpected failure: %v", err)
			}
			expectUsed(t, r, baseUsed)

			if err := r.DryRun().Release(cidr.IP); err != nil {

	"runtime"
	"strconv"
	"strings"
	"testing"
	"time"
)

var (
	update  = flag.Bool("u", false, "update test reference files")
	verbose = flag.Bool("v", false, "print debugger interactions (very verbose)")
	dryrun  = flag.Bool("n", false, "just print the command line and first debugging bits")
	useGdb  = flag.Bool("g", false, "use Gdb instead of Delve (dlv), use gdb reference files")

		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	if m.DryRun != nil {
		i--
		if *m.DryRun {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x58
	}
	{
		size, err := m.OldObject.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err

			requestOptions:  &metav1.CreateOptions{DryRun: []string{"All"}},
			evictionOptions: &metav1.DeleteOptions{},
		},
		{
			name:            "just eviction-options",
			requestOptions:  &metav1.CreateOptions{},
			evictionOptions: &metav1.DeleteOptions{DryRun: []string{"All"}},
		},
		{
			name:            "both options",
			evictionOptions: &metav1.DeleteOptions{DryRun: []string{"All"}},

		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenerated(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	if m.DryRun != nil {
		i--
		if *m.DryRun {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x58
	}
	{
		size, err := m.OldObject.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err

// until all are ready or a timeout is reached
func WaitForResources(objects object.K8sObjects, client kube.Client,
	waitTimeout time.Duration, dryRun bool, l *progress.ManifestLog,
) error {
	if dryRun || TestMode {
		return nil
	}

	if err := waitForCRDs(objects, client); err != nil {
		return err
	}

	var notReady []string
	var debugInfo map[string]string

)

type UserWithTable struct {
	gorm.Model
	Name string
}

func (UserWithTable) TableName() string {
	return "gorm.user"
}

func TestTable(t *testing.T) {
	dryDB := DB.Session(&gorm.Session{DryRun: true})

	r := dryDB.Table("`user`").Find(&User{}).Statement
	if !regexp.MustCompile("SELECT \\* FROM `user`").MatchString(r.Statement.SQL.String()) {
		t.Errorf("Table with escape character, got %v", r.Statement.SQL.String())