typename T6, typename T7>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
             ::std::ostream* os) {
  PrintTupleTo(t, os);
}

template <typename T1, typename T2, typename T3, typename T4, typename T5,
          typename T6, typename T7, typename T8>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
             ::std::ostream* os) {

          typename T6, typename T7>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
             ::std::ostream* os) {
  PrintTupleTo(t, os);
}

template <typename T1, typename T2, typename T3, typename T4, typename T5,
          typename T6, typename T7, typename T8>
void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
             ::std::ostream* os) {

			requestedNamespace: "t7-ns1",
			recursive:          true,
			fieldSelector:      fields.ParseSelectorOrDie("metadata.namespace=t7-ns2"),
			watchTests: []*testWatchStruct{
				{baseNamespacedPod("t7-foo1", "t7-ns1"), false, ""},
				{baseNamespacedPod("t7-foo1", "t7-ns2"), false, ""},
				{baseNamespacedPodUpdated("t7-foo1", "t7-ns1"), false, ""},
				{baseNamespacedPodUpdated("t7-foo1", "t7-ns2"), false, ""},
			},

            val t6: Copy = tasks.getByName<Copy>("bar") {
                description += "C"
                destinationDir = file("out")
            }

            val t6: Task = tasks.create("bazar")
            val t7: Copy = tasks.create("cathedral", Copy::class)
            val t8: Copy = tasks.create<Copy>("cabin")

            val t9: Task = tasks.create("castle") {
                description += "!"
            }

	t1 int = i + j
	t2 int = i /* ERROR "mismatched types" */ + x
	t3 int = c /* ERRORx `cannot use .* variable declaration` */ + d
	t4 string = s + t
	t5 string = s /* ERROR "invalid operation" */ / t
	t6 byte = array[t1]
	t7 byte = array[x /* ERROR "must be integer" */]
	t8 *int = & /* ERRORx `cannot use .* variable declaration` */ a
	t10 *int = &42 /* ERROR "cannot take address" */
	t11 *complex64 = &v
	t12 complex64 = -(u + *t11) / *&v

			}},
			badNameInURL: true,
			eviction:     &policy.Eviction{ObjectMeta: metav1.ObjectMeta{Name: "t7", Namespace: "default"}, DeleteOptions: metav1.NewDeleteOptions(0)},
			expectError:  "name in URL does not match name in Eviction object: BadRequest",
			podName:      "t7",
		},
		{
			name: "matching pdbs with no disruptions allowed, pod running, empty selector",

00000000  17 03 03 00 8b 69 2e 81  c4 4d 43 a6 1f 96 b7 8e  |.....i...MC.....|
00000010  87 4a 9b be 48 3c 31 18  98 f4 8c 04 24 b2 52 96  |.J..H<1.....$.R.|
00000020  04 b5 12 7c 54 37 83 6d  51 42 c6 52 f4 a5 bc d3  |...|T7.mQB.R....|
00000030  d1 c8 29 ab 4f e4 02 da  74 ec 8e 13 ad 03 f3 e0  |..).O...t.......|
00000040  7f 44 58 6b c7 28 a5 6a  75 30 b8 b1 31 38 fe ba  |.DXk.(.ju0..18..|

func TestDefaultsInArray(t *testing.T) {
	type Type7 struct {
		B []bool
		I []int
		S []string
		F []float64
	}
	t7 := Type7{
		[]bool{false, false, true},
		[]int{0, 0, 1},
		[]string{"hi", "", "there"},
		[]float64{0, 0, 1},
	}
	var t7p Type7
	if err := encAndDec(t7, &t7p); err != nil {
		t.Error(err)
	}
}

var testInt int
var testFloat32 float32
var testString string

00000120  44 28 03 3b b6 f8 0a 0e  b4 cb 5e 5b 57 0f c0 2f  |D(.;......^[W../|
00000130  59 4f 13 e3 9c 02 18 b1  ce 94 78 05 18 64 73 c6  |YO........x..ds.|
00000140  05 89 d1 54 37 18 ea 09  61 08 c5 6a 54 f6 48 44  |...T7...a..jT.HD|
00000150  40 63 6a 53 b9 41 5f 4f  8e 05 e7 31 7b 08 d0 67  |@cjS.A_O...1{..g|
00000160  8e bf 56 c4 56 0a 82 b2  74 6a 89 dd b4 f7 3c 0b  |..V.V...tj....<.|

)

// valid array types
type (
	T5 [10]*T5                // T5 contains T5 as component of a pointer
	T6 [10]func() T6          // T6 contains T6 as component of a function type
	T7 [10]struct{ f []T7 }   // T7 contains T7 as component of a slice in a struct
)
</pre>

<h3 id="Slice_types">Slice types</h3>

<p>
A slice is a descriptor for a contiguous segment of an <i>underlying array</i> and