}
			frames = append(frames, pc)

			if _, ok := pcs[pc]; !ok {
				pcs[pc] = frame{
					pc:     pc,
					funcID: stringID(funcID),
					fileID: stringID(fileID),
					line:   line,
				}
			}
		}

		// Add the stack to the map.
		if err := stackTable.insert(stackID(id), stack{pcs: frames}); err != nil {
			return err
		}
	}
	return nil

// See golang.org/issue/22237
func TestDecodeMemoryConsumption(t *testing.T) {
	const frames = 3000
	img := image.NewPaletted(image.Rectangle{Max: image.Point{1, 1}}, palette.WebSafe)
	hugeGIF := &GIF{
		Image:    make([]*image.Paletted, frames),
		Delay:    make([]int, frames),
		Disposal: make([]byte, frames),
	}
	for i := 0; i < frames; i++ {
		hugeGIF.Image[i] = img
		hugeGIF.Delay[i] = 60
	}
	buf := new(bytes.Buffer)

				framesz := unsafe.Sizeof((any)(nil)) + f.nret
				if framecap < framesz {
					// The frame does not contain pointers interesting for GC,
					// all not yet finalized objects are stored in finq.
					// If we do not mark it as FlagNoScan,
					// the last finalized object is not collected.
					frame = mallocgc(framesz, nil, true)
					framecap = framesz
				}

				if f.fint == nil {

 * limitations under the License.
 */

package org.gradle.internal.problems.failure;

import java.util.List;

/**
 * Content of a thrown exception with classified stack frames.
 * <p>
 * Failures can have multiple causes via the {@link org.gradle.internal.exceptions.MultiCauseException}.
 * <p>
 * Failures are guaranteed to not have circular references.
 *
 * @see FailureFactory
 */

The maximum stack depth for alloc, mutex, block, threadcreate and goroutine

					{"main.main.func11", 0},
				}},
			}...)
		}
		stackMatches := func(stk trace.Stack, frames []frame) bool {
			i := 0
			match := true
			stk.Frames(func(f trace.StackFrame) bool {
				if f.Func != frames[i].fn {
					match = false
					return false
				}
				if line := uint64(frames[i].line); line != 0 && line != f.Line {
					match = false
					return false
				}
				i++

  }

  @Test
  fun clientCloseCancelsConnectionAfterTimeout() {
    client.webSocket!!.close(1000, "Hello!")
    taskFaker.runTasks()
    // Note: we don't process server frames so our client 'close' doesn't receive a server 'close'.
    assertThat(client.canceled).isFalse()

    taskFaker.advanceUntil(ns(RealWebSocket.CANCEL_AFTER_CLOSE_MILLIS - 1))
    assertThat(client.canceled).isFalse()

   */
  private fun doReadTimeout() = !connection.client || sink.closed || sink.finished

  /**
   * A source that reads the incoming data frames of a stream. Although this class uses
   * synchronization to safely receive incoming data frames, it is not intended for use by multiple
   * readers.
   */
  inner class FramingSource internal constructor(

  /**
   * HTTP/2 only. Send a push promise header block.
   *
   * A push promise contains all the headers that pertain to a server-initiated request, and a
   * `promisedStreamId` to which response frames will be delivered. Push promise frames are sent as
   * a part of the response to `streamId`. The `promisedStreamId` has a priority of one greater than
   * `streamId`.
   *
   * @param streamId client-initiated stream ID.  Must be an odd number.

import okhttp3.internal.closeQuietly
import okio.Buffer
import okio.BufferedSource
import okio.ByteString
import okio.buffer
import okio.source

/** Replays prerecorded outgoing frames and records incoming frames.  */
class MockHttp2Peer : Closeable {
  private var frameCount = 0
  private var client = false
  private val bytesOut = Buffer()
  private var writer = Http2Writer(bytesOut, client)