}
			}),
		}, {
			name:          "LoadBalancerIPMode disabled, ipMode used in old and in new",
			ipModeEnabled: false,
			svc: makeValidServiceCustom(func(svc *api.Service) {
				svc.Spec.Type = api.ServiceTypeLoadBalancer
				svc.Status.LoadBalancer = api.LoadBalancerStatus{
					Ingress: []api.LoadBalancerIngress{{
						IP:     "1.2.3.4",
						IPMode: &ipModeProxy,
					}},
				}
			}),

	example.net/pkgremoved v0.1.0 => ./prpkg
	example.net/pkgremoved v0.1.1 => ./prpkg

	example.net/pkgremoved v0.2.0 => ./prmod
	example.net/pkgremoved v0.2.1 => ./prmod

	example.net/pkgremoved v0.3.0 => ./prpkg
	example.net/pkgremoved v0.3.1 => ./prmod

	example.net/pkgremoved v0.4.0 => ./prmod
	example.net/pkgremoved v0.4.1 => ./prpkg
)
-- other/go.mod --
module example.net/other

go 1.16

        childResolver.dirMode == 0x2

        when:
        child.fileMode = 0x3
        child.dirMode = 0x4

        then:
        childResolver.fileMode == 0x3
        childResolver.dirMode == 0x4
    }

    def canWalkDownTreeCreatedUsingFromIntegrationTest() {

        CopySpec child = parentSpec.from('somedir') { into 'child' }
        child.from('somedir') { into 'grandchild' }

		t.Fatalf("unexpected clash after reset: %v", err)
	}
}

func TestBasic(t *testing.T) {
	scenarios := []struct {
		cmode         coverage.CounterMode
		cgran         coverage.CounterGranularity
		src, dst, res []uint32
		iters         int
		merr          bool
		overflow      bool
	}{
		{
			cmode:    coverage.CtrModeSet,
			cgran:    coverage.CtrGranularityPerBlock,
			src:      []uint32{1, 0, 1},

			svc := obj.(*v1.Service)
			for i, s := range svc.Status.LoadBalancer.Ingress {
				got := s.IPMode
				expected := tc.expectedIPMode[i]
				if !reflect.DeepEqual(got, expected) {
					t.Errorf("Expected IPMode %v, got %v", tc.expectedIPMode[i], s.IPMode)
				}
			}
		})
	}
}

func TestSetDefaultSecretVolumeSource(t *testing.T) {
	s := v1.PodSpec{}

        spec.dirMode == 0655
        toPermissionString(spec.dirPermissions.get()) == "rw-r-xr-x"
        spec.filteringCharset == 'UTF8'

        where:
        method             | setter
        "mode"                  | { DefaultCopySpec spec, ObjectFactory objectFactory ->
            spec.fileMode = 0444
            spec.dirMode = 0655
        }

apiVersion: telemetry.istio.io/v1alpha1
kind: Telemetry
metadata:
  name: logs
spec:
  accessLogging:
    - providers:
        - name: envoy
      match:

	}
	newmode := mfr.CounterMode()
	if newmode != ts.cmode {
		return fmt.Errorf("internal error: counter mode clash: %q from test harness, %q from data file %s", ts.cmode.String(), newmode.String(), p.MetaFile)
	}
	newgran := mfr.CounterGranularity()
	if err := ts.cm.SetModeAndGranularity(p.MetaFile, cmode, newgran); err != nil {
		return err
	}

		defer cancel()
		_, h, err := r.exchange(ctx, tt.server, tt.question, time.Second, useUDPOrTCP, false)
		if err != nil {
			t.Error(err)
			continue
		}
		if h.RCode != tt.rcode {
			t.Errorf("got %v from %v; want %v", h.RCode, tt.server, tt.rcode)
			continue
		}
	}
}

func TestDNSTransportNoFallbackOnTCP(t *testing.T) {
	fake := fakeDNSServer{

		if err != nil {
			return mode, retainDate, legalHold, toAPIErrorCode(ctx, err)
		}
		rMode, rDate, err := objectlock.ParseObjectLockRetentionHeaders(rq.Header)
		if err != nil && !(replica && rMode == "" && rDate.IsZero()) {
			return mode, retainDate, legalHold, toAPIErrorCode(ctx, err)
		}
		if retentionPermErr != ErrNone {
			return mode, retainDate, legalHold, retentionPermErr
		}
		return rMode, rDate, legalHold, ErrNone
	}