assertNotNull(res, "null graph after resolver");
        assertNotNull(res.getVertices(), "no vertices in the resulting graph after resolver");

        assertNotNull(res.getExcidentEdges(v1), "no edges in the resulting graph after resolver");

        assertEquals(4, res.getVertices().size(), "wrong # of vertices in the resulting graph after resolver");
        assertEquals(
                2,

-- input --
Text.
 - List immediately after.
 - Another.

More text.

 - List after blank line.
 - Another.

Even more text.
 - List immediately after.

 - Blank line between items.

Yet more text.

 - Another list after blank line.

 - Blank line between items.

Still more text.
 - One list item.

   Multiple paragraphs.
-- dump --
Doc
	Paragraph
		Plain "Text."

            "ok out\n" +
            "after out\n" +
            "test constructed\n" +
            "before out\n" +
            "test out: \u03b1</html>\n" +
            "after out\n" +
            "after class out\n"
        ))
        classReport.assertStderr(containsString(
            "before class err\n" +
            "before err\n" +
            "ok err\n" +
            "after err\n" +
            "before err\n" +

        name == "first"
        tracker.root
        tracker.segments.empty
        tracker.toRelativePath() == ""
    }

    def "can enter and leave second level"() {
        given:
        tracker.enter("root")
        tracker.enter("first")
        when:
        tracker.enter("second")
        then:
        !tracker.root
        tracker.segments as List == ["first", "second"]

sealed interface SocketPolicy {
  /**
   * Shutdown [MockWebServer] after writing response.
   */
  object ShutdownServerAfterResponse : SocketPolicy

  /**
   * Keep the socket open after the response. This is the default HTTP/1.1 behavior.
   */
  object KeepOpen : SocketPolicy

  /**
   * Close the socket after the response. This is the default HTTP/1.0 behavior. For HTTP/2

	slices.Sort(toDelete)

	// Collect output after insertion point, with lines deleted, into after.
	var after []byte
	start := insert
	for _, end := range toDelete {
		if end < start {
			continue
		}
		after = appendLines(after, p.output[start:end])
		start = end + len(p.lineAt(end))
	}
	after = appendLines(after, p.output[start:])
	if n := len(after); n >= 2 && isNL(after[n-1]) && isNL(after[n-2]) {
		after = after[:n-1]

		},
		{
			callbacks: []callback{{h: c1, after: "c3"}, {h: c2, before: "c4", after: "c5"}, {h: c3, before: "c5"}, {h: c4}, {h: c5}},
			results:   []string{"c3", "c1", "c5", "c2", "c4"},
		},
		{
			callbacks: []callback{{h: c1, before: "c4", after: "c3"}, {h: c2, before: "c4", after: "c5"}, {h: c3, before: "c5"}, {h: c4}, {h: c5}},
			results:   []string{"c3", "c1", "c5", "c2", "c4"},
		},
		{

	}

	var mu sync.Mutex
	var before, after []byte
	f.Cleanup(func() {
		sort.Slice(after, func(i, j int) bool { return after[i] < after[j] })
		got := string(before) + string(after)
		want := "abcabc"
		if got != want {
			f.Fatalf("got %q; want %q", got, want)
		}
	})

	f.Fuzz(func(t *testing.T, b []byte) {
		before = append(before, b...)
		t.Parallel()
		mu.Lock()
		after = append(after, b...)
		mu.Unlock()
	})

				}
			} else if idx := getRIndex(names, c.after); idx != -1 {
				// if after callback exists but haven't sorted
				// set after callback's before callback to current callback
				after := cs[idx]

				if after.before == "" {
					after.before = c.name
				}

				if err := sortCallback(after); err != nil {
					return err
				}

// are replied with a 429 and the following response headers:
//   - 'Retry-After: N` (so client can retry after N seconds, hopefully on a new apiserver instance)
//   - 'Connection: close': tear down the TCP connection
//
// TODO: is there a way to merge WithWaitGroup and this filter?
func WithRetryAfter(handler http.Handler, shutdownDelayDurationElapsedCh <-chan struct{}) http.Handler {