str   string
	ints  []uint64
}{
	{[]byte{}, false, "", nil},
	{[]byte{0x80, 0x01}, false, "", nil},
	{[]byte{0x01, 0x80, 0x01}, false, "", nil},

	{[]byte{1, 2, 3}, true, "0.1.2.3", []uint64{0, 1, 2, 3}},
	{[]byte{41, 2, 3}, true, "1.1.2.3", []uint64{1, 1, 2, 3}},
	{[]byte{86, 2, 3}, true, "2.6.2.3", []uint64{2, 6, 2, 3}},

	{[]byte{41, 255, 255, 255, 127}, true, "1.1.268435455", []uint64{1, 1, 268435455}},

		},
		"bad-parameters-namespace": {
			wantFailures: field.ErrorList{field.Invalid(field.NewPath("parametersRef", "namespace"), badName, "a lowercase RFC 1123 label must consist of lower case alphanumeric characters or '-', and must start and end with an alphanumeric character (e.g. 'my-name',  or '123-abc', regex used for validation is '[a-z0-9]([-a-z0-9]*[a-z0-9])?')")},
			class: func() *resource.ResourceClass {
				class := testClass(goodName, goodName)

			template:     testClaimTemplate("", goodNS, goodClaimSpec),
		},
		"bad-name": {

	// Output:
	// 10
	// [0 1 2 3]
	// 4
	// 4
}

func ExampleConcat() {
	s1 := []int{0, 1, 2, 3}
	s2 := []int{4, 5, 6}
	concat := slices.Concat(s1, s2)
	fmt.Println(concat)
	// Output:
	// [0 1 2 3 4 5 6]
}

func ExampleContains() {
	numbers := []int{0, 1, 2, 3}
	fmt.Println(slices.Contains(numbers, 2))
	fmt.Println(slices.Contains(numbers, 4))
	// Output:
	// true

namespace tensorflow {
namespace generator {

string Call(const string& object, const string& method,
            std::vector<string> arguments, const char* oper) {
  return absl::Substitute("$0$1$2($3)", object, oper, method,
                          absl::StrJoin(arguments, ", "));
}

string Call(const string& function, std::vector<string> arguments) {

			claim:        testClaim("", goodNS, goodClaimSpec),
		},
		"bad-name": {

			<version>${utflute.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.mortbay.jetty</groupId>
			<artifactId>jetty</artifactId>
			<version>6.1.23</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${slf4j.version}</version>
			<scope>test</scope>

  // CHECK-NEXT:     tf_device.return %[[IDINSIDE]] : tensor<f32>
  // CHECK-NEXT:   }) : () -> tensor<f32>
  // CHECK-NEXT:   "tf_device.cluster"() ({
  // CHECK-NEXT:     %[[GROUP:.*]] = "tf.Const"()
  // CHECK-SAME:       [0, 1, 2, 3]
  // CHECK-NEXT:     %[[REDUCED:.*]] = "tf.XlaAllReduce"(%[[ID]], %[[GROUP]]) <{mode = "CrossReplica", reduce_op = "Add"}> : (tensor<f32>, tensor<1x4xi32>) -> tensor<f32>

				t.Errorf("found unknown STW event; update stwReasonStrings?")
			}
		}
	}
}

func TestBuckets(t *testing.T) {
	var evs Events

	const N = eventsBucketSize*3 + 123
	for i := 0; i < N; i++ {
		evs.append(Event{Ts: Timestamp(i)})
	}

	if n := len(evs.buckets); n != 4 {
		t.Fatalf("got %d buckets, want %d", n, 4)
	}

	if n := evs.Len(); n != N {

	// For example, a handler called "runc" might specify that the runc OCI
	// runtime (using native Linux containers) will be used to run the containers
	// in a pod.
	// The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements,
	// and is immutable.
	Handler string `json:"handler" protobuf:"bytes,2,opt,name=handler"`

	// overhead represents the resource overhead associated with running a pod for a