return filepath.SkipDir
		}
		return nil
	})

	wantSeen := []string{"dir", "dir/dontskip", "dir/dontskip/file.go", "dir/dontskip/skip", "dir/skip"}

	if len(seen) != len(wantSeen) {
		t.Errorf("paths seen in walk: got %v entries; want %v entries", len(seen), len(wantSeen))
	}

	for i := 0; i < len(seen) && i < len(wantSeen); i++ {
		if seen[i] != wantSeen[i] {

	if len(tab.baseList) != 1+len(tab.indexMap) { // indexMap omits nil
		t.Errorf("table length discrepancy: %d != 1+%d", len(tab.baseList), len(tab.indexMap))
	}

	const wantLen = 4
	if len(tab.baseList) != wantLen {
		t.Errorf("got table length %d; want %d", len(tab.baseList), wantLen)
	}

	if got := tab.XPos(NoPos); got != NoXPos {
		t.Errorf("XPos(NoPos): got %v; want %v", got, NoXPos)
	}

		// that *i crashes for some reason. Still, why not check it.
		log.Fatalf("bad i value: got %d, want %d", *i, iValue)
	}

	const wantLen = 125
	const wantCap = 1912

	sl := arena.MakeSlice[*int](a, wantLen, wantCap)
	if len(sl) != wantLen {
		log.Fatalf("bad arena slice length: got %d, want %d", len(sl), wantLen)
	}
	if cap(sl) != wantCap {
		log.Fatalf("bad arena slice capacity: got %d, want %d", cap(sl), wantCap)
	}
	sl = sl[:cap(sl)]

			if m == nil {
				continue
			}
			containsVal = true
			s, err := strconv.Unquote(string(m[1]))
			if err != nil {
				panic(err)
			}
			if len(s) != wantLen {
				fmt.Fprintf(os.Stderr, "expect length %d, got %d (%q)\n", wantLen, len(s), line)
				os.Exit(1)
			}
		}
		if !containsVal {
			fmt.Fprintln(os.Stderr, "corpus file contained no values")
			os.Exit(1)
		}
	}
}

	}
	res.Body.Close()

	wantFoo := "bar"
	wantLen := int64(-1)
	if method == "OPTIONS" {
		wantFoo = ""
		wantLen = 0
	}
	if res.StatusCode != 200 {
		t.Errorf("status code = %v; want %d", res.Status, 200)
	}
	if res.ContentLength != wantLen {
		t.Errorf("content length = %v; want %d", res.ContentLength, wantLen)
	}
	if got := res.Header.Get("foo"); got != wantFoo {

				cs = ""
			}
			if typ.Is(ChecksumIncludesMultipart) {
				wantLen := int(t) * length
				if len(b) < wantLen {
					break
				}
				// Read part checksum
				if part > 0 && uint64(part) <= t {
					offset := (part - 1) * length
					partCs := b[offset:]
					cs = base64.StdEncoding.EncodeToString(partCs[:length])
				}
				b = b[wantLen:]
			}
		} else if part > 1 {

	}
	reset := func() { s = connRequestSet{} }

	t.Run("add-delete", func(t *testing.T) {
		reset()
		wantLen(0)
		dh := s.Add(nil)
		wantLen(1)
		if !s.Delete(dh) {
			t.Fatal("failed to delete")
		}
		wantLen(0)
		if s.Delete(dh) {
			t.Error("delete worked twice")
		}
		wantLen(0)
	})
	t.Run("take-before-delete", func(t *testing.T) {
		reset()
		ch1 := make(chan connRequest)

		req, _ := NewRequest("GET", "http://foo.localhost"+tt.path, nil)
		FileServer(fileServerCleanPathDir{&log}).ServeHTTP(rr, req)
		if !reflect.DeepEqual(log, tt.wantOpen) {
			t.Logf("For %s: Opens = %q; want %q", tt.path, log, tt.wantOpen)
		}
		if rr.Code != tt.wantCode {
			t.Logf("For %s: Response code = %d; want %d", tt.path, rr.Code, tt.wantCode)
		}
	}
}

	if version != timeBinaryVersionV1 && version != timeBinaryVersionV2 {
		return errors.New("Time.UnmarshalBinary: unsupported version")
	}

	wantLen := /*version*/ 1 + /*sec*/ 8 + /*nsec*/ 4 + /*zone offset*/ 2
	if version == timeBinaryVersionV2 {
		wantLen++
	}
	if len(buf) != wantLen {
		return errors.New("Time.UnmarshalBinary: invalid length")
	}

	buf = buf[1:]

			q.Activate(logger, map[string]*v1.Pod{"test_pod": tt.qPodInfoToActivate.PodInfo.Pod})

			// Check the result after activation by the length of activeQ
			if wantLen := len(tt.want); q.activeQ.Len() != wantLen {
				t.Errorf("length compare: want %v, got %v", wantLen, q.activeQ.Len())
			}

			// Check if the specific pod exists in activeQ
			for _, want := range tt.want {