}

// ObjectTooLarge error returned when the size of the object > max object size allowed (5G) per request.
type ObjectTooLarge GenericError

func (e ObjectTooLarge) Error() string {
	return "size of the object greater than what is allowed(5G)"
}

// ObjectTooSmall error returned when the size of the object < what is expected.
type ObjectTooSmall GenericError

// converted to int they correspond to the rune size that was read.
type readOp int8

// Don't use iota for these, as the values need to correspond with the
// names and comments, which is easier to see when being explicit.
const (
	opRead      readOp = -1 // Any other read operation.
	opInvalid   readOp = 0  // Non-read operation.
	opReadRune1 readOp = 1  // Read rune of size 1.
	opReadRune2 readOp = 2  // Read rune of size 2.

                  assertEquals(k3(), k);
                  assertNull(v);
                  return v3();
                }));
    expectAdded(e3());
    assertEquals(getNumElements() + 1, getMap().size());
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testCompute_absentToAbsent() {
    assertNull(
        "Map.compute(absent, functionReturningNull) should return null",
        getMap()

                  assertEquals(k3(), k);
                  assertNull(v);
                  return v3();
                }));
    expectAdded(e3());
    assertEquals(getNumElements() + 1, getMap().size());
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testCompute_absentToAbsent() {
    assertNull(
        "Map.compute(absent, functionReturningNull) should return null",
        getMap()

    sort(entries, Helpers.<K, V>entryComparator(navigableMap.comparator()));

    // some tests assume SEVERAL == 3
    if (entries.size() >= 1) {
      a = entries.get(0);
      if (entries.size() >= 3) {
        c = entries.get(2);
      }
    }
  }

  @CollectionSize.Require(ZERO)
  public void testEmptyMapFirst() {

    Builder<K, V> combine(Builder<K, V> other) {
      checkNotNull(other);
      ensureCapacity(this.size + other.size);
      arraycopy(
          other.alternatingKeysAndValues,
          0,
          this.alternatingKeysAndValues,
          this.size * 2,
          other.size * 2);
      this.size += other.size;
      return this;
    }

    private ImmutableMap<K, V> build(boolean throwIfDuplicateKeys) {

                    artifact.getDependencyTrail()));
        }

        buffer.append("----------").append(LS);

        int size = artifacts.size();

        buffer.append(size).append(" required artifact");

        if (size > 1) {
            buffer.append("s are");
        } else {
            buffer.append(" is");
        }

    private CountDownLatch endLatch;

    @Test
    void testTransferProgressedWithPrintResourceNames() throws Exception {
        int size = 1000;
        ExecutorService service = Executors.newFixedThreadPool(size * 2);
        startLatch = new CountDownLatch(size);
        endLatch = new CountDownLatch(size);
        Map<String, String> output = new ConcurrentHashMap<String, String>();

    ImmutableSet.Builder<String> builder = ImmutableSet.builderWithExpectedSize(4);
    builder.add("a");
    assertEquals(1, builder.size);
    builder.add("a");
    assertEquals(1, builder.size);
    builder.add("b", "c", "d");
    assertEquals(4, builder.size);
    Object[] table = builder.hashTable;
    assertNotNull(table);
    assertSame(table, ((RegularImmutableSet<String>) builder.build()).table);
  }

  }

  /**
   * Returns the number of bytes currently being used to store the values in this cache. This may be
   * greater than the max size if a background deletion is pending.
   */
  @Synchronized
  @Throws(IOException::class)
  fun size(): Long {
    initialize()
    return size
  }

  @Synchronized
  @Throws(IOException::class)
  internal fun completeEdit(
    editor: Editor,
    success: Boolean,