} catch (Exception e) { // sneaky checked exception
        if (exception == null) {
          exception = e;
        } else {
          exception.addSuppressed(e);
        }
      }
    }
    if (exception != null) {
      // Normally this is a RuntimeException that doesn't need sneakyThrow.
      // But theoretically we could see sneaky checked exception
      sneakyThrow(exception);
    }
  }

      } catch (Exception | Error unsafeFailure) { // sneaky checked exception
        thrownUnsafeFailure = unsafeFailure;
        // Catch absolutely everything and fall through to AtomicReferenceFieldUpdaterAtomicHelper.
        try {
          helper = new AtomicReferenceFieldUpdaterAtomicHelper();
        } catch (Exception // sneaky checked exception
            | Error atomicReferenceFieldUpdaterFailure) {

            int start = dstIndex;
            dstIndex += writeHeaderWireFormat(dst, dstIndex);
            dstIndex += writeBytesWireFormat(dst, dstIndex);

            // Set the length field that will be checked by ServerMessageBlock2Request.encode()
            int calculatedLength = testEncodedLength;
            setLength(calculatedLength);

        verify(tree, times(1)).close(); // try-with-resources must close
        verify(handle, never()).markClosed();
        verify(tree, never()).hasCapability(anyInt()); // not checked on SMB2
    }

    // SMB1 path: without CAP_NT_SMBS it should throw SmbUnsupportedOperationException
    @Test
    @DisplayName("watch() SMB1 without capability throws unsupported")

   * {@code null}; it may either return a non-null value or throw an exception.
   *
   * <p>No observable state associated with this cache is modified until loading completes.
   *
   * @throws ExecutionException if a checked exception was thrown while loading the value
   * @throws UncheckedExecutionException if an unchecked exception was thrown while loading the
   *     value
   * @throws ExecutionError if an error was thrown while loading the value

        v.add(new DERTaggedObject(true, 2, new DERBitString(new byte[] { 0x02 })));
        // Tag 3 should be passed as ASN1TaggedObject which will be checked for APPLICATION tag class
        // Create a context-specific tagged object (wrong tag class)
        v.add(new DERTaggedObject(true, 3, new DERTaggedObject(true, 0, new DERSequence(new ASN1EncodableVector()))));

  }

  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  protected final boolean supportsValuesHashCode(Map<K, V> map) {
    // get the first non-null value
    Collection<V> values = map.values();
    for (V value : values) {
      if (value != null) {
        try {
          int unused = value.hashCode();
        } catch (Exception e) { // sneaky checked exception
          return false;
        }

    DataOutputStream dout = new DataOutputStream(out);
    dout.writeByte(SignedBytes.checkedCast(strategy.ordinal()));
    dout.writeByte(UnsignedBytes.checkedCast(numHashFunctions)); // note: checked at the c'tor
    dout.writeInt(bits.data.length());
    for (int i = 0; i < bits.data.length(); i++) {
      dout.writeLong(bits.data.get(i));
    }
  }

  /**

            // We've exhausted our current label. Either there are more labels to compare, in which
            // case we expect a dot as the next character. Otherwise, we've checked all our labels.
            if (currentLabelIndex == labels.size - 1) {
              break
            } else {
              currentLabelIndex++
              currentLabelByteIndex = -1

     *
     * <p><b>Note:</b> in general, code should assume that the string form returned by {@code
     * ToStringHelper} for a given object may change. In particular, the list of types which are
     * checked for emptiness is subject to change. We currently check {@code CharSequence}s, {@code
     * Collection}s, {@code Map}s, optionals (including Guava's), and arrays.
     *
     * @since 33.4.0
     */