Dmitri Shuralyov <******@****.***> 1721666689 -0400

    assertMapEquals(ImmutableBiMap.of("one", 1, "two", 2).inverse(), 1, "one", 2, "two");
    assertMapEquals(
        ImmutableBiMap.of("one", 1, "two", 2, "three", 3), "one", 1, "two", 2, "three", 3);
    assertMapEquals(
        ImmutableBiMap.of("one", 1, "two", 2, "three", 3).inverse(),
        1,
        "one",
        2,
        "two",
        3,

    map.put("bar", 3);
    assertEquals("{foo=[1], bar=[2, 3]}", map.toString());
    assertEquals("[foo=1, bar=2, bar=3]", map.entries().toString());
  }

  public void testLinkedPutOutOfOrder() {
    Multimap<String, Integer> map = create();
    map.put("bar", 1);
    map.put("foo", 2);
    map.put("bar", 3);
    assertEquals("{bar=[1, 3], foo=[2]}", map.toString());

      String[] suffix = {"h", "i"};

      String[] all = new String[2 + elements.length + 2];
      arraycopy(prefix, 0, all, 0, 2);
      arraycopy(elements, 0, all, 2, elements.length);
      arraycopy(suffix, 0, all, 2 + elements.length, 2);

      return ImmutableList.copyOf(all).subList(2, elements.length + 2);
    }
  }

  }

  public void testOf() {
    assertMapEquals(ImmutableMap.of("one", 1), "one", 1);
    assertMapEquals(ImmutableMap.of("one", 1, "two", 2), "one", 1, "two", 2);
    assertMapEquals(
        ImmutableMap.of("one", 1, "two", 2, "three", 3), "one", 1, "two", 2, "three", 3);
    assertMapEquals(
        ImmutableMap.of("one", 1, "two", 2, "three", 3, "four", 4),
        "one",

            Bytes.indexOf(
                new byte[] {(byte) 2, (byte) 3, (byte) 2, (byte) 3, (byte) 4, (byte) 2, (byte) 3},
                new byte[] {(byte) 2, (byte) 3, (byte) 4}))
        .isEqualTo(2);
    assertThat(
            Bytes.indexOf(
                new byte[] {(byte) 2, (byte) 2, (byte) 3, (byte) 4, (byte) 2, (byte) 3, (byte) 4},
                new byte[] {(byte) 2, (byte) 3, (byte) 4}))
        .isEqualTo(1);
    assertThat(

	}
	if err := ps.Subscribe(Mask(2), ch2, doneCh, nil); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	ps.Lock()
	defer ps.Unlock()

	if len(ps.subs) != 2 {
		t.Fatalf("expected 2 subscribers")
	}
	if want, got := int32(2), ps.NumSubscribers(Mask(1)); got != want {
		t.Fatalf("want %d subscribers, got %d", want, got)
	}
	if want, got := int32(2), ps.NumSubscribers(Mask(2)); got != want {

  // additional CPU.
  const char* second_device_name =
      "/job:localhost/replica:0/task:0/device:CUSTOM:1";
  std::array<const char*, 2> second_underlying_devices{
      "/job:localhost/replica:0/task:0/device:CUSTOM:0",
      "/job:localhost/replica:0/task:0/device:CPU:2"};
  RegisterParallelDevice(context.get(), second_device_name,
                         second_underlying_devices, status.get());

  public void testSerialization_singleElement() {
    validateReserialization(ImmutableTable.of('a', 2, "foo"));
  }

  public void testDenseSerialization_manualOrder() {
    ImmutableTable.Builder<Character, Integer, String> builder = ImmutableTable.builder();
    builder.put('b', 2, "foo");
    builder.put('b', 1, "bar");
    builder.put('a', 2, "baz");
    Table<Character, Integer, String> table = builder.build();

                new float[] {
                  (float) 2, (float) 3, (float) 2, (float) 3, (float) 4, (float) 2, (float) 3
                },
                new float[] {(float) 2, (float) 3, (float) 4}))
        .isEqualTo(2);
    assertThat(
            Floats.indexOf(
                new float[] {
                  (float) 2, (float) 2, (float) 3, (float) 4, (float) 2, (float) 3, (float) 4
                },