apply {
    this.request = request
  }

fun Response.Builder.commonProtocol(protocol: Protocol) =
  apply {
    this.protocol = protocol
  }

fun Response.Builder.commonCode(code: Int) =
  apply {
    this.code = code
  }

fun Response.Builder.commonMessage(message: String) =
  apply {
    this.message = message
  }

fun Response.Builder.commonHeader(
  name: String,

  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require({SUPPORTS_REMOVE, SUPPORTS_PUT})
  public void testPropagatesRemoveThenAddToMultimap() {
    int oldSize = getNumElements();

    Collection<V> result = multimap().asMap().get(k0());
    assertTrue(result.remove(v0()));

    assertFalse(multimap().containsKey(k0()));

  /** Gets the context for the given event. */
  private SubscriberExceptionContext context(Object event) {
    return new SubscriberExceptionContext(bus, event, target, method);
  }

  @Override
  public final int hashCode() {
    return (31 + method.hashCode()) * 31 + System.identityHashCode(target);
  }

  @Override
  public final boolean equals(@CheckForNull Object obj) {
    if (obj instanceof Subscriber) {

        this.sorter = new ProjectSorter(projects);
        this.order = new HashMap<>();
        this.projects = new HashMap<>();
        List<MavenProject> sorted = this.sorter.getSortedProjects();
        for (int index = 0; index < sorted.size(); index++) {
            MavenProject project = sorted.get(index);
            String id = ProjectSorter.getId(project);
            this.projects.put(id, project);

				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *TierConfigMgr) Msgsize() (s int) {
	s = 1 + 6 + msgp.MapHeaderSize
	if z.Tiers != nil {
		for za0001, za0002 := range z.Tiers {
			_ = za0002
			s += msgp.StringPrefixSize + len(za0001) + za0002.Msgsize()
		}
	}
	return

			delete(entry.ReqClaims, filterKey)
			delete(entry.ReqQuery, filterKey)
			delete(entry.ReqHeader, filterKey)
			delete(entry.RespHeader, filterKey)
		}

		var (
			statusCode      int
			timeToResponse  time.Duration
			timeToFirstByte time.Duration
			outputBytes     int64 = -1 // -1: unknown output bytes
			headerBytes     int64
		)

	"time"
)

// LogOnce provides the function type for logger.LogOnceIf() function
type LogOnce func(ctx context.Context, err error, id string, errKind ...interface{})

type onceErr struct {
	Err   error
	Count int
}

// Holds a map of recently logged errors.
type logOnceType struct {
	IDMap map[string]onceErr
	sync.Mutex
}

				return
			}
			s = s[size:]
		}
	}
}

// splitSeq is SplitSeq or SplitAfterSeq, configured by how many
// bytes of sep to include in the results (none or all).
func splitSeq(s, sep []byte, sepSave int) iter.Seq[[]byte] {
	if len(sep) == 0 {
		return explodeSeq(s)
	}
	return func(yield func([]byte) bool) {
		for {
			i := Index(s, sep)
			if i < 0 {
				break
			}
			frag := s[:i+sepSave]

                logger.warn("Destroying {} because of the process timeout.", getName());
                p.destroy();
            }

            final int exitValue = p.exitValue();
            if (exitValue != 0) {
                logger.warn("{} is failed (exit code:{}, timeout:{}): {}", getName(), exitValue, task.isExecuted(), commandList);
            }

  public void testBuilderExactlySizedReusesArray() {
    ImmutableBiMap.Builder<Integer, Integer> builder = ImmutableBiMap.builderWithExpectedSize(10);
    Entry<Integer, Integer>[] builderArray = builder.entries;
    for (int i = 0; i < 10; i++) {
      builder.put(i, i);
    }
    Entry<Integer, Integer>[] builderArrayAfterPuts = builder.entries;
    RegularImmutableBiMap<Integer, Integer> map =