t.Fatalf("want %d subscribers, got %d", want, got)
	}
}

func TestSubscribeExceedingLimit(t *testing.T) {
	ps := New[Maskable, Maskable](2)
	ch1 := make(chan Maskable, 1)
	ch2 := make(chan Maskable, 1)
	ch3 := make(chan Maskable, 1)
	doneCh := make(chan struct{})
	defer close(doneCh)
	if err := ps.Subscribe(MaskAll, ch1, doneCh, nil); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	remoteHost := remote.HostName()

	// 1: Echo
	serverSent := make(chan struct{})
	serverCanceled := make(chan struct{})
	register := func(manager *Manager) {
		errFatal(manager.RegisterStreamingHandler(handlerTest, StreamHandler{
			Handle: func(ctx context.Context, payload []byte, _ <-chan []byte, resp chan<- []byte) *RemoteErr {
				// Send many responses.
				// Test that this doesn't block.

var errSignatureMismatch = errors.New("Signature does not match")

// When upload object size is greater than 5G in a single PUT/POST operation.
var errDataTooLarge = errors.New("Object size larger than allowed limit")

// When upload object size is less than what was expected.
var errDataTooSmall = errors.New("Object size smaller than expected")

// errServerNotInitialized - server not initialized.

// constant. See the Go language specification's "Length and capacity" section for
// details.
func cap(v Type) int

// The make built-in function allocates and initializes an object of type
// slice, map, or chan (only). Like new, the first argument is a type, not a
// value. Unlike new, make's return type is the same as the type of its
// argument, not a pointer to it. The specification of the result depends on
// the type:
//

  /**
   * Returns an element less than the {@link #samples()} and less than {@link
   * #belowSamplesGreater()}.
   */
  E belowSamplesLesser();

  /**
   * Returns an element less than the {@link #samples()} but greater than {@link
   * #belowSamplesLesser()}.
   */
  E belowSamplesGreater();

  /**
   * Returns an element greater than the {@link #samples()} but less than {@link
   * #aboveSamplesGreater()}.
   */

  /**
   * Returns an element less than the {@link #samples()} and less than {@link
   * #belowSamplesGreater()}.
   */
  E belowSamplesLesser();

  /**
   * Returns an element less than the {@link #samples()} but greater than {@link
   * #belowSamplesLesser()}.
   */
  E belowSamplesGreater();

  /**
   * Returns an element greater than the {@link #samples()} but less than {@link
   * #aboveSamplesGreater()}.
   */

	// SS parity drives should be greater than or equal to minParityDrives.
	// Parity below minParityDrives is not supported.
	if ssParity > 0 && ssParity < minParityDrives {
		return fmt.Errorf("parity %d should be greater than or equal to %d",
			ssParity, minParityDrives)
	}

	if ssParity > setDriveCount/2 {
		return fmt.Errorf("parity %d should be less than or equal to %d", ssParity, setDriveCount/2)
	}

  SortedMap<K, V> create(Object... elements);

  /**
   * Returns an entry with a key less than the keys of the {@link #samples()} and less than the key
   * of {@link #belowSamplesGreater()}.
   */
  Entry<K, V> belowSamplesLesser();

  /**
   * Returns an entry with a key less than the keys of the {@link #samples()} but greater than the
   * key of {@link #belowSamplesLesser()}.
   */
  Entry<K, V> belowSamplesGreater();

func (m *muxClient) handleTwowayResponses(responseCh chan<- Response, internalResp <-chan Response) {
	defer m.parent.deleteMux(false, m.MuxID)
	defer xioutil.SafeClose(responseCh)
	for resp := range internalResp {
		responseCh <- resp
		m.send(message{Op: OpUnblockSrvMux, MuxID: m.MuxID})
	}
}

func (m *muxClient) handleTwowayRequests(internalResp chan<- Response, requests <-chan []byte) {
	var errState bool
	if debugPrint {

}

func (client *peerRESTClient) GetResourceMetrics(ctx context.Context) (<-chan MetricV2, error) {
	resp, err := getResourceMetricsRPC.Call(ctx, client.gridConn(), grid.NewMSS())
	if err != nil {
		return nil, err
	}
	ch := make(chan MetricV2)
	go func(ch chan<- MetricV2) {
		defer close(ch)
		for _, m := range resp.Value() {
			if m == nil {
				continue
			}