*
 * @author Charles Fry
 * @since 10.0
 */
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public abstract class ForwardingCache<K, V> extends ForwardingObject implements Cache<K, V> {

  /** Constructor for use by subclasses. */
  protected ForwardingCache() {}

  @Override
  protected abstract Cache<K, V> delegate();

  /** @since 11.0 */
  @Override
  @CheckForNull
  public V getIfPresent(Object key) {

                                                       TFE_TensorHandle* tensor,
                                                       TF_Status* status) const;

  // Construct a parallel tensor consisting of the scalar values from `values`.
  template <typename DataType>
  std::unique_ptr<ParallelTensor> ScalarsFromSequence(
      absl::Span<const DataType> values, TFE_Context* context,

  }

  @Test fun `cannot decode constructed octet string`() {
    assertFailsWith<ProtocolException> {
      Adapters.OCTET_STRING.fromDer(
        "2410040668656c6c6f200406776f726c6421".decodeHex(),
      )
    }.also { expected ->
      assertThat(expected).hasMessage("constructed octet strings not supported for DER")
    }
  }

  @Test fun `cannot decode constructed bit string`() {

     */
    public SMB1SigningDigest ( byte[] macSigningKey ) {
        this.digest = Crypto.getMD5();
        this.macSigningKey = macSigningKey;
    }


    /**
     * Construct a digest with a non-zero starting sequence number
     * 
     * @param macSigningKey
     * @param initialSequence
     */
    public SMB1SigningDigest ( byte[] macSigningKey, int initialSequence ) {

    Constructor<ArrayList> constructor = ArrayList.class.getConstructor();
    assertEquals(
        TypeToken.of(ArrayList.class),
        TypeToken.of(ArrayList.class).constructor(constructor).getOwnerType());
    assertEquals(
        new TypeToken<ArrayList<String>>() {},
        new TypeToken<ArrayList<String>>() {}.constructor(constructor).getOwnerType());
  }

        MemberType.TYPE -> hasTypeAttribute(kmClass, jvmSignature, predicate)
        MemberType.FIELD -> hasPropertyAttribute(kmClass::properties, jvmSignature, predicate)
        MemberType.CONSTRUCTOR -> hasConstructorAttribute(kmClass::constructors, jvmSignature, predicate)
        MemberType.METHOD -> hasFunctionAttribute(kmClass::functions, jvmSignature, predicate) ||
            hasPropertyAttribute(kmClass::properties, jvmSignature, predicate)

    // requireNonNull is safe because we use indexes that were populated by the constructor.
    V value = requireNonNull(values[rowIndex][columnIndex]);
    return cellOf(rowKey, columnKey, value);
  }

  @Override
  V getValue(int index) {
    // requireNonNull is safe because we use indexes that were populated by the constructor.
    return requireNonNull(values[cellRowIndices[index]][cellColumnIndices[index]]);
  }

   */
  public static <E> ImmutableList<E> of(E e1, E e2) {
    return construct(e1, e2);
  }

  /**
   * Returns an immutable list containing the given elements, in order.
   *
   * @throws NullPointerException if any element is null
   */
  public static <E> ImmutableList<E> of(E e1, E e2, E e3) {
    return construct(e1, e2, e3);
  }

  /**

   *
   * <p>Instances of {@code exceptionClass} are created by choosing an arbitrary public constructor
   * that accepts zero or more arguments, all of type {@code String} or {@code Throwable}
   * (preferring constructors with at least one {@code String}, then preferring constructors with at
   * least one {@code Throwable}) and calling the constructor via reflection. If the exception did

    Constructor<ArrayList> constructor = ArrayList.class.getConstructor();
    assertEquals(
        TypeToken.of(ArrayList.class),
        TypeToken.of(ArrayList.class).constructor(constructor).getOwnerType());
    assertEquals(
        new TypeToken<ArrayList<String>>() {},
        new TypeToken<ArrayList<String>>() {}.constructor(constructor).getOwnerType());
  }