var mutex sync.Mutex
	printOnce := make(map[Endpoint]map[string]int)

	return func(endpoint Endpoint, err error, once bool) {
		reqInfo := (&logger.ReqInfo{}).AppendTags("endpoint", endpoint.String())
		ctx := logger.SetReqInfo(GlobalContext, reqInfo)
		mutex.Lock()
		defer mutex.Unlock()

		m, ok := printOnce[endpoint]
		if !ok {
			m = make(map[string]int)
			printOnce[endpoint] = m
			if once {
				m[err.Error()]++

    HashSet<String> mut = Sets.union(friends, enemies).copyInto(new HashSet<String>());

    enemies.add("Buck");
    assertEquals(6, all.size());
    assertEquals(5, immut.size());
    assertEquals(5, mut.size());
  }

  public void testIntersection() {
    Set<String> friends = newHashSet("Tom", "Joe", "Dave");
    Set<String> enemies = newHashSet("Dick", "Harry", "Tom");

  public Test testsForCheckedMap() {
    return MapTestSuiteBuilder.using(
            new TestStringMapGenerator() {
              @Override
              protected Map<String, String> create(Entry<String, String>[] entries) {
                Map<String, String> map = populate(new HashMap<String, String>(), entries);
                return Collections.checkedMap(map, String.class, String.class);
              }
            })

  public Test testsForCheckedMap() {
    return MapTestSuiteBuilder.using(
            new TestStringMapGenerator() {
              @Override
              protected Map<String, String> create(Entry<String, String>[] entries) {
                Map<String, String> map = populate(new HashMap<String, String>(), entries);
                return Collections.checkedMap(map, String.class, String.class);
              }
            })

        new Function<String, String>() {
          @Override
          public String apply(String value) {
            return Ascii.toLowerCase(value);
          }
        };

    static final EntryTransformer<String, String, String> ENTRY_TRANSFORMER =
        new EntryTransformer<String, String, String>() {
          @Override
          public String transformEntry(String key, String value) {
            return Ascii.toLowerCase(value);

In the examples we use a `MSS` type, which is a `map[string]string` that is `msgp` serializable.

```go
    handler := func(request *grid.MSS) (*grid.MSS, *grid.RemoteErr) {
        fmt.Println("Got request with field", request["myfield"])
        // Do something with payload
        return NewMSSWith(map[string]string{"result": "ok"}), nil
    }
	
    // Create a typed handler.

     */
    void interpolate(
            @Nonnull Map<String, String> map,
            @Nullable Function<String, String> callback,
            @Nullable BiFunction<String, String, String> postprocessor,
            boolean defaultsToEmpty);

    /**
     * Interpolates a single string value using the provided callback function.
     * This method defaults to not replacing unresolved placeholders.

    String[] array = new String[] {"a"};
    List<String[]> list = ImmutableList.<String[]>of(array);
    assertEquals(singletonList(array), list);
  }

  public void testCopyOf_emptyArray() {
    String[] array = new String[0];
    List<String> list = ImmutableList.copyOf(array);
    assertEquals(emptyList(), list);
  }

  public void testCopyOf_arrayOfOneElement() {
    String[] array = new String[] {"a"};

        fail("Encoding $component $codePoint using $encoding")
      }
      return
    }

    // Check that the URI and HttpURL have the exact same escaping.
    if (toAndFromUri != httpUrl) {
      fail("Encoding $component $codePoint using $encoding")
    }
    if (uri.toString() != httpUrl.toString()) {
      fail("Encoding $component $codePoint using $encoding")
    }
  }

  private static Test testsForTransform() {
    return CollectionTestSuiteBuilder.using(
            new TestStringCollectionGenerator() {
              @Override
              public Collection<@Nullable String> create(@Nullable String[] elements) {
                List<@Nullable String> list = newArrayList();
                for (String element : elements) {
                  list.add((element == null) ? null : "q" + element);