idleAtNs = idleAtNanos,
      )
    result.withLock { pool.put(result) }
    return result
  }

  fun newConnectionPool(
    taskRunner: TaskRunner = this.taskRunner,
    maxIdleConnections: Int = Int.MAX_VALUE,
    routePlanner: RoutePlanner? = null,
  ): RealConnectionPool {
    return RealConnectionPool(
      taskRunner = taskRunner,
      maxIdleConnections = maxIdleConnections,

			if err != nil {
				return err
			}
			if len(entries) > 0 {
				return errVolumeNotEmpty
			}
			return nil
		}, index)
	}

	return g.Wait()
}

func isAllVolumeNotFound(errs []error) bool {
	return countErrs(errs, errVolumeNotFound) == len(errs)
}

// isAllNotFound will return if any element of the error slice is not

          "multiset.remove(absent, 2) didn't return 0 or throw an exception",
          0,
          getMultiset().remove(e3(), 2));
    } catch (UnsupportedOperationException ok) {
    }
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_occurrences_0() {
    int oldCount = getMultiset().count(e0());
    assertEquals(
        "multiset.remove(E, 0) didn't return the old count",
        oldCount,

    if (defaultValue != null) {
      return defaultValue;
    }
    Class<? extends T> implementation = getImplementation(type);
    if (implementation != null) {
      return get(implementation);
    }
    if (type == Stream.class) {
      return type.cast(Stream.empty());
    }
    if (type.isEnum()) {
      T[] enumConstants = type.getEnumConstants();

  @Override
  public SampleElements<Object> samples() {
    return new Colliders();
  }

  @Override
  public Object[] createArray(int length) {
    return new Object[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<Object> order(List<Object> insertionOrder) {
    return insertionOrder;
  }

        break
      }
      val codePoint = prefix.readUtf8CodePoint()
      if (Character.isISOControl(codePoint) && !Character.isWhitespace(codePoint)) {
        return false
      }
    }
    return true
  } catch (_: EOFException) {
    return false // Truncated UTF-8 sequence.
  }

   */
  @J2ktIncompatible
  @GwtIncompatible // reflection
  public static Method getListIteratorFullyModifiableMethod() {
    return getMethod(ListListIteratorTester.class, "testListIterator_fullyModifiable");
  }

  /**
   * Returns the {@link Method} instance for {@link #testListIterator_unmodifiable()} so that it can
   * be suppressed in GWT tests.
   */
  @J2ktIncompatible

    return t;
  }

  /** Returns {@code null} as any type, even one that does not include {@code null}. */
  @SuppressWarnings({"nullness", "TypeParameterUnusedInFormals", "ReturnMissingNullable"})
  // The warnings are legitimate. Each time we use this method, we document why.
  @ParametricNullness
  static <T extends @Nullable Object> T unsafeNull() {
    return null;
  }

  private NullnessCasts() {}

    return t;
  }

  /** Returns {@code null} as any type, even one that does not include {@code null}. */
  @SuppressWarnings({"nullness", "TypeParameterUnusedInFormals", "ReturnMissingNullable"})
  // The warnings are legitimate. Each time we use this method, we document why.
  @ParametricNullness
  static <T extends @Nullable Object> T unsafeNull() {
    return null;
  }

  private NullnessCasts() {}

}

// updateCacheEntry will update a cache.
// Returns the updated status.
func (b *bucketMetacache) updateCacheEntry(update metacache) (metacache, error) {
	b.mu.Lock()
	defer b.mu.Unlock()
	existing, ok := b.caches[update.id]
	if !ok {
		return update, errFileNotFound
	}
	existing.update(update)
	b.caches[update.id] = existing
	b.updated = true
	return existing, nil
}